xia
feat: TTS multilingue + STT autodetect + HIL fix + vouvoiement + guide lecture + cancel_scheduled
f268e25 Download src/agents/tools.py from xbizot/saearch: direct link, hf CLI and curl.
- Browser
- Download file 48 kB
-
https://huggingface.co/spaces/xbizot/saearch/resolve/main/src/agents/tools.py
- Command line
-
hf download hf://spaces/xbizot/saearch/src/agents/tools.py
-
curl -L -o tools.py https://huggingface.co/spaces/xbizot/saearch/resolve/main/src/agents/tools.py
48 kB
"""
Outils pour l'agent LangGraph Agentic RAG.
7 outils :
1. get_weather → météo actuelle (OpenMeteo)
2. get_historical_weather → météo historique (OpenMeteo Archive)
3. get_forecast → prévisions météo 7 jours (OpenMeteo)
4. web_search → recherche web (Tavily + DuckDuckGo fallback)
5. calculator → calculs mathématiques
6. search_corpus → recherche hybride dans le corpus RAG (BM25 + Dense)
7. send_email → envoi d'email d'alerte climatique
"""
import logging
import math
import os
import re
import requests
from duckduckgo_search import DDGS
from langchain_core.tools import tool
from src.config import (
METEO_FORECAST_DAYS,
OPENMETEO_BASE_URL,
OPENMETEO_GEOCODING_URL,
)
logger = logging.getLogger(__name__)
# ══════════════════════════════════════════════════════════════════
# UTILITAIRE — Géocodage (partagé entre les 3 outils météo)
# ══════════════════════════════════════════════════════════════════
_WMO_CODES: dict[int, str] = {
0: "Ciel dégagé",
1: "Principalement dégagé",
2: "Partiellement nuageux",
3: "Couvert",
45: "Brouillard",
48: "Brouillard givrant",
51: "Bruine légère",
53: "Bruine modérée",
55: "Bruine dense",
61: "Pluie légère",
63: "Pluie modérée",
65: "Pluie forte",
71: "Neige légère",
73: "Neige modérée",
75: "Neige forte",
77: "Grains de neige",
80: "Averses légères",
81: "Averses modérées",
82: "Averses violentes",
85: "Averses de neige",
86: "Averses de neige fortes",
95: "Orage",
96: "Orage avec grêle",
99: "Orage violent avec grêle",
}
def _geocode(city: str) -> tuple[float, float, str] | None:
"""Géocode une ville via l'API gratuite Open-Meteo geocoding."""
try:
resp = requests.get(
OPENMETEO_GEOCODING_URL,
params={"name": city, "count": 1, "language": "fr"},
timeout=10,
)
resp.raise_for_status()
results = resp.json().get("results", [])
if not results:
return None
r = results[0]
return r["latitude"], r["longitude"], r.get("name", city)
except Exception:
return None
# ══════════════════════════════════════════════════════════════════
# OUTIL 1 — Météo actuelle (OpenMeteo)
# ══════════════════════════════════════════════════════════════════
@tool
def get_weather(city: str) -> str:
"""
Récupère la météo actuelle d'une ville via l'API OpenMeteo (gratuit, sans clé).
Args:
city: Nom de la ville (ex: "Paris", "Lyon", "Bogota")
Returns:
Résumé météo : conditions, température, humidité, vent, précipitations.
"""
logger.info("Appel get_weather pour %s", city)
geo = _geocode(city)
if geo is None:
return f"Impossible de trouver la ville « {city} »."
lat, lon, city_name = geo
try:
params = {
"latitude": lat,
"longitude": lon,
"current": (
"temperature_2m,apparent_temperature,relative_humidity_2m,"
"weather_code,wind_speed_10m,precipitation,surface_pressure"
),
"timezone": "auto",
"forecast_days": 1,
}
resp = requests.get(f"{OPENMETEO_BASE_URL}/forecast", params=params, timeout=10)
resp.raise_for_status()
cur = resp.json()["current"]
except requests.RequestException as exc:
return f"Erreur API météo pour « {city_name} » : {exc}"
wmo = cur.get("weather_code", 0)
conditions = _WMO_CODES.get(wmo, f"Code WMO {wmo}")
return (
f"Météo actuelle à {city_name}\n"
f"- Conditions : {conditions}\n"
f"- Température : {cur.get('temperature_2m', 'N/A')} °C "
f"(ressenti {cur.get('apparent_temperature', 'N/A')} °C)\n"
f"- Humidité : {cur.get('relative_humidity_2m', 'N/A')} %\n"
f"- Vent : {cur.get('wind_speed_10m', 'N/A')} km/h\n"
f"- Précipitations: {cur.get('precipitation', 0)} mm\n"
f"- Pression : {cur.get('surface_pressure', 'N/A')} hPa"
)
# ══════════════════════════════════════════════════════════════════
# OUTIL 2 — Météo historique (OpenMeteo Archive)
# ══════════════════════════════════════════════════════════════════
@tool
def get_historical_weather(city: str, date: str) -> str:
"""
Récupère la météo historique d'une ville à une date passée via OpenMeteo Archive.
Args:
city: Nom de la ville (ex: "Marseille", "Paris")
date: Date au format YYYY-MM-DD (ex: "2023-01-15")
Returns:
Résumé météo du jour : température min/max, précipitations, vent max.
"""
logger.info("Appel get_historical_weather pour %s le %s", city, date)
geo = _geocode(city)
if geo is None:
return f"Impossible de trouver la ville « {city} »."
lat, lon, city_name = geo
try:
params = {
"latitude": lat,
"longitude": lon,
"start_date": date,
"end_date": date,
"daily": (
"temperature_2m_max,temperature_2m_min,"
"precipitation_sum,wind_speed_10m_max,weather_code"
),
"hourly": "temperature_2m,relative_humidity_2m,wind_speed_10m",
"timezone": "auto",
}
resp = requests.get(
"https://archive-api.open-meteo.com/v1/archive", params=params, timeout=10
)
resp.raise_for_status()
data = resp.json()
daily = data["daily"]
hourly = data.get("hourly", {})
except requests.RequestException as exc:
return f"Erreur API météo historique pour « {city_name} » le {date} : {exc}"
if not daily.get("time"):
return f"Aucune donnée disponible pour « {city_name} » le {date}."
wmo = daily.get("weather_code", [0])[0]
conditions = _WMO_CODES.get(wmo, f"Code WMO {wmo}")
result = (
f"Météo historique à {city_name} le {date}\n"
f"- Conditions : {conditions}\n"
f"- Température max : {daily.get('temperature_2m_max', ['N/A'])[0]} °C\n"
f"- Température min : {daily.get('temperature_2m_min', ['N/A'])[0]} °C\n"
f"- Précipitations : {daily.get('precipitation_sum', [0])[0]} mm\n"
f"- Vent max : {daily.get('wind_speed_10m_max', ['N/A'])[0]} km/h"
)
# Ajouter les donnees horaires si disponibles
temps = hourly.get("temperature_2m", [])
if temps:
result += "\n\nDonnees horaires (temperature) :"
hours = hourly.get("time", [])
for i, (h, t) in enumerate(zip(hours, temps)):
heure = h.split("T")[1] if "T" in h else f"{i:02d}:00"
result += f"\n {heure} : {t} °C"
return result
# ══════════════════════════════════════════════════════════════════
# OUTIL 3 — Prévisions météo 7 jours (OpenMeteo Forecast)
# ══════════════════════════════════════════════════════════════════
@tool
def get_forecast(city: str) -> str:
"""
Récupère les prévisions météo des 7 prochains jours via OpenMeteo.
Args:
city: Nom de la ville (ex: "Lyon", "Marseille")
Returns:
Prévisions jour par jour : température min/max, précipitations, vent.
"""
logger.info("Appel get_forecast pour %s", city)
geo = _geocode(city)
if geo is None:
return f"Impossible de trouver la ville « {city} »."
lat, lon, city_name = geo
try:
params = {
"latitude": lat,
"longitude": lon,
"daily": (
"temperature_2m_max,temperature_2m_min,"
"precipitation_sum,wind_speed_10m_max,weather_code"
),
"timezone": "auto",
"forecast_days": METEO_FORECAST_DAYS,
}
resp = requests.get(f"{OPENMETEO_BASE_URL}/forecast", params=params, timeout=10)
resp.raise_for_status()
daily = resp.json()["daily"]
except requests.RequestException as exc:
return f"Erreur API prévisions pour « {city_name} » : {exc}"
lines = [f"Prévisions météo à {city_name} ({METEO_FORECAST_DAYS} jours)\n"]
for i, day in enumerate(daily.get("time", [])):
wmo = daily.get("weather_code", [0])[i]
conditions = _WMO_CODES.get(wmo, f"Code WMO {wmo}")
t_max = daily.get("temperature_2m_max", ["N/A"])[i]
t_min = daily.get("temperature_2m_min", ["N/A"])[i]
precip = daily.get("precipitation_sum", [0])[i]
wind = daily.get("wind_speed_10m_max", ["N/A"])[i]
lines.append(
f" {day} : {conditions}, {t_min}-{t_max}°C, "
f"pluie {precip}mm, vent {wind}km/h"
)
return "\n".join(lines)
# ══════════════════════════════════════════════════════════════════
# OUTIL 4 — Recherche web (Tavily en prio, DuckDuckGo en fallback)
# ══════════════════════════════════════════════════════════════════
def _search_tavily(query: str, max_results: int = 5) -> str | None:
"""Recherche via Tavily (optimisé LLM). Retourne None si indisponible."""
api_key = os.getenv("TAVILY_API_KEY")
if not api_key:
return None
try:
from tavily import TavilyClient
client = TavilyClient(api_key=api_key)
response = client.search(query, max_results=max_results)
results = response.get("results", [])
if not results:
return None
lines = [f"Résultats Tavily pour : « {query} »\n"]
for i, r in enumerate(results, 1):
title = r.get("title", "Sans titre")
url = r.get("url", "")
content = r.get("content", "")
snippet = content[:300].strip() + ("..." if len(content) > 300 else "")
lines.append(f"{i}. {title}\n {url}\n {snippet}\n")
logger.info("Recherche Tavily réussie pour : %s", query)
return "\n".join(lines)
except Exception as exc:
logger.warning("Tavily indisponible, fallback DuckDuckGo : %s", exc)
return None
def _search_duckduckgo(query: str, max_results: int = 5) -> str:
"""Recherche via DuckDuckGo (fallback)."""
try:
with DDGS() as ddgs:
results = list(ddgs.text(query, max_results=max_results))
except Exception as exc:
return f"Erreur lors de la recherche web : {exc}"
if not results:
return f"Aucun résultat trouvé pour : « {query} »"
lines = [f"Résultats DuckDuckGo pour : « {query} »\n"]
for i, r in enumerate(results, 1):
title = r.get("title", "Sans titre")
href = r.get("href", "")
body = r.get("body", "")
snippet = body[:300].strip() + ("..." if len(body) > 300 else "")
lines.append(f"{i}. {title}\n {href}\n {snippet}\n")
return "\n".join(lines)
@tool
def web_search(query: str, max_results: int = 5) -> str:
"""
Recherche web pour des informations récentes.
Utilise Tavily (optimisé LLM) en priorité, DuckDuckGo en fallback.
Args:
query: Requête de recherche en langage naturel.
max_results: Nombre maximum de résultats (défaut : 5).
Returns:
Liste des résultats avec titre, URL et extrait.
"""
logger.info("Appel web_search pour : %s", query)
# Tavily en priorité
result = _search_tavily(query, max_results)
if result is not None:
return result
# Fallback DuckDuckGo
return _search_duckduckgo(query, max_results)
# ══════════════════════════════════════════════════════════════════
# OUTIL 5 — Calculatrice (avec garde-fou regex)
# ══════════════════════════════════════════════════════════════════
_SAFE_GLOBALS = {
"__builtins__": {},
"abs": abs,
"round": round,
"min": min,
"max": max,
"sum": sum,
"pow": pow,
"int": int,
"float": float,
"sqrt": math.sqrt,
"log": math.log,
"log10": math.log10,
"log2": math.log2,
"exp": math.exp,
"sin": math.sin,
"cos": math.cos,
"tan": math.tan,
"asin": math.asin,
"acos": math.acos,
"atan": math.atan,
"ceil": math.ceil,
"floor": math.floor,
"pi": math.pi,
"e": math.e,
"inf": math.inf,
}
_SAFE_FUNC_NAMES = (
"sqrt|log|log10|log2|sin|cos|tan|asin|acos|atan|"
"exp|ceil|floor|abs|round|min|max|sum|pow|int|float|pi|inf"
)
@tool
def calculator(expression: str) -> str:
"""
Évalue une expression mathématique et retourne le résultat.
Args:
expression: Expression mathématique (ex: "3+7*2", "sqrt(144)", "log(1000)/log(10)")
Returns:
Le résultat numérique ou un message d'erreur.
"""
logger.info("Appel calculator pour : %s", expression)
expr = expression.strip()
# Garde-fou : rejeter les caractères non mathématiques
cleaned = re.sub(_SAFE_FUNC_NAMES, "", expr)
if re.search(r"[a-zA-Z]{2,}", cleaned):
return (
f"Expression non reconnue : « {expression} ». "
"Utilisez uniquement des opérateurs mathématiques."
)
try:
result = eval(expr, _SAFE_GLOBALS, {}) # noqa: S307
if isinstance(result, float) and result.is_integer():
formatted = str(int(result))
elif isinstance(result, float):
formatted = f"{result:.6g}"
else:
formatted = str(result)
return f"{expression} = {formatted}"
except ZeroDivisionError:
return "Erreur : division par zéro."
except (ValueError, TypeError, OverflowError) as exc:
return f"Erreur de calcul : {exc}"
except Exception as exc:
return f"Expression invalide : {exc}"
# ══════════════════════════════════════════════════════════════════
# OUTIL 6 — Recherche hybride dans le corpus RAG (BM25 + Dense)
# ══════════════════════════════════════════════════════════════════
# Singleton pour ne pas recharger le vector store à chaque appel
_cached_vector_store = None
_cached_chunks = None
_cached_hybrid_retriever = None
def _get_hybrid_retriever():
"""Charge le retriever hybride une seule fois (singleton)."""
global _cached_vector_store, _cached_chunks, _cached_hybrid_retriever
if _cached_hybrid_retriever is not None:
return _cached_hybrid_retriever
from src.rag.embeddings import charger_vector_store
from src.rag.hybrid_retriever import creer_hybrid_retriever
_cached_vector_store = charger_vector_store()
if _cached_vector_store is None:
return None
# Extraction des chunks directement depuis le FAISS docstore.
# Avantages : (1) marche en container sans data/raw/, (2) plus rapide
# (pas de re-parsing PDFs), (3) garantit coherence chunks BM25 = chunks Dense.
try:
_cached_chunks = list(_cached_vector_store.docstore._dict.values())
logger.info(
"Chunks extraits du FAISS docstore : %d (sans recharger PDFs)",
len(_cached_chunks),
)
except Exception as exc:
logger.warning("Echec extraction chunks FAISS, fallback PDFs : %s", exc)
from src.rag.loader import charger_et_decouper
_cached_chunks = charger_et_decouper("data/raw")
_cached_hybrid_retriever = creer_hybrid_retriever(
_cached_vector_store, _cached_chunks
)
logger.info("Retriever hybride BM25+Dense chargé (singleton)")
return _cached_hybrid_retriever
@tool
def search_corpus(question: str) -> str:
"""
Recherche hybride (BM25 + Dense) dans le corpus de documents climatiques
(PDFs GIEC, Copernicus, EM-DAT, etc.). Combine recherche sémantique et
recherche par mots-clés pour une meilleure couverture.
Args:
question: Question en langage naturel sur les catastrophes climatiques.
Returns:
Passages pertinents avec citations [Source: fichier, Page: X].
"""
logger.info("Appel search_corpus pour : %s", question)
retriever = _get_hybrid_retriever()
if retriever is None:
# Fallback sur le retriever dense seul
from src.rag.embeddings import charger_vector_store
from src.rag.retriever import creer_retriever, interroger_rag
vector_store = charger_vector_store()
if vector_store is None:
return "Le vector store n'est pas disponible. Lancez d'abord embeddings.py."
retriever_dense = creer_retriever(vector_store)
resultat = interroger_rag(retriever_dense, question)
return resultat["contexte"]
from src.rag.retriever import formater_contexte_avec_citations
docs = retriever.invoke(question)
return formater_contexte_avec_citations(docs)
# ══════════════════════════════════════════════════════════════════
# OUTIL 7 — Envoi d'email (alertes climatiques)
# ══════════════════════════════════════════════════════════════════
@tool
def send_email(destinataire: str, sujet: str, contenu: str) -> str:
"""
Envoie un email d'alerte ou de rapport climatique.
Args:
destinataire: Adresse email du destinataire.
sujet: Sujet du mail.
contenu: Corps du mail en texte.
Returns:
Confirmation d'envoi ou message d'erreur.
"""
logger.info("Appel send_email vers %s : %s", destinataire, sujet)
# Resoudre le nom en email si besoin
if "@" not in destinataire:
resolved = TEAM_DIRECTORY.get(destinataire.strip().lower())
if resolved:
destinataire = resolved
email_address = os.getenv("EMAIL_ADDRESS")
email_password = os.getenv("EMAIL_APP_PASSWORD")
if not email_address or not email_password:
return (
"Email non configuré. Ajoutez EMAIL_ADDRESS et EMAIL_APP_PASSWORD dans .env"
)
try:
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
msg = MIMEMultipart()
msg["From"] = email_address
msg["To"] = destinataire
msg["Subject"] = sujet
msg.attach(MIMEText(contenu, "plain", "utf-8"))
with smtplib.SMTP("smtp.gmail.com", 587) as server:
server.starttls()
server.login(email_address, email_password)
server.send_message(msg)
logger.info("Email envoyé à %s", destinataire)
return f"Email envoyé à {destinataire} : {sujet}"
except Exception as exc:
logger.error("Erreur envoi email : %s", exc)
return f"Erreur lors de l'envoi : {exc}"
# ══════════════════════════════════════════════════════════════════
# OUTIL 7b — Envoi d'email groupé (alertes climatiques)
# ══════════════════════════════════════════════════════════════════
# Emails equipe charges depuis env (jamais dans le code public).
# Format attendu dans .env :
# TEAM_DIRECTORY_JSON={"kamila":"xxx@mail.com","xia":"xxx@mail.com",...}
# TEAM_EMAILS est deduit automatiquement des valeurs du dict.
import json as _json
_directory_json = os.getenv("TEAM_DIRECTORY_JSON", "{}")
try:
TEAM_DIRECTORY = _json.loads(_directory_json)
except _json.JSONDecodeError:
logger.warning("TEAM_DIRECTORY_JSON mal formate, fallback vide")
TEAM_DIRECTORY = {}
TEAM_EMAILS = list(TEAM_DIRECTORY.values())
@tool
def send_bulk_email(destinataires: str, sujet: str, contenu: str) -> str:
"""
Envoie un email a plusieurs destinataires en meme temps.
Utilise cet outil pour les alertes climatiques groupees,
les rapports envoyes a une equipe, ou les notifications de masse.
Args:
destinataires: Adresses email separees par des virgules (ex: "a@test.com, b@test.com").
sujet: Sujet du mail.
contenu: Corps du mail en texte.
Returns:
Confirmation d'envoi avec le nombre de destinataires.
"""
logger.info("Appel send_bulk_email : %s", sujet)
email_address = os.getenv("EMAIL_ADDRESS")
email_password = os.getenv("EMAIL_APP_PASSWORD")
if not email_address or not email_password:
return (
"Email non configure. Ajoutez EMAIL_ADDRESS et EMAIL_APP_PASSWORD dans .env"
)
# Parser les destinataires
dest_lower = destinataires.lower()
if any(
kw in dest_lower for kw in ["equipe", "team", "tous", "tout le monde", "all"]
):
emails = TEAM_EMAILS
else:
# Resoudre les noms en emails via le repertoire
emails = []
for part in destinataires.split(","):
part = part.strip()
if "@" in part:
emails.append(part)
else:
# Chercher par nom dans le repertoire
resolved = TEAM_DIRECTORY.get(part.lower())
if resolved:
emails.append(resolved)
if not emails:
noms_dispo = ", ".join(TEAM_DIRECTORY.keys())
return f"Aucune adresse trouvee. Noms disponibles : {noms_dispo}"
try:
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
envoyes = 0
erreurs = []
with smtplib.SMTP("smtp.gmail.com", 587) as server:
server.starttls()
server.login(email_address, email_password)
for dest in emails:
try:
msg = MIMEMultipart()
msg["From"] = email_address
msg["To"] = dest
msg["Subject"] = sujet
msg.attach(MIMEText(contenu, "plain", "utf-8"))
server.send_message(msg)
envoyes += 1
logger.info("Email envoye a %s", dest)
except Exception as exc:
erreurs.append(f"{dest}: {exc}")
logger.error("Erreur envoi a %s : %s", dest, exc)
result = f"Email envoye a {envoyes}/{len(emails)} destinataires : {sujet}"
if erreurs:
result += f"\nErreurs : {'; '.join(erreurs)}"
return result
except Exception as exc:
logger.error("Erreur envoi email groupe : %s", exc)
return f"Erreur lors de l'envoi groupe : {exc}"
# ══════════════════════════════════════════════════════════════════
# OUTIL 7c — Programmation d'email differe (scheduling)
# ══════════════════════════════════════════════════════════════════
_scheduler = None
def _get_scheduler():
"""Retourne l'instance BackgroundScheduler (lazy init + persistance SQLite)."""
global _scheduler
if _scheduler is None:
try:
from apscheduler.schedulers.background import BackgroundScheduler
from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
# Persistance : jobs survivent au restart (SQLite local dedie)
jobstores = {
"default": SQLAlchemyJobStore(url="sqlite:///scheduler_jobs.db")
}
# misfire_grace_time 1h : rattrape les jobs manques au redemarrage
job_defaults = {"misfire_grace_time": 3600, "coalesce": True}
_scheduler = BackgroundScheduler(
jobstores=jobstores,
job_defaults=job_defaults,
timezone="Europe/Paris",
)
_scheduler.start()
logger.info(
"APScheduler demarre (timezone Europe/Paris, "
"persistance SQLite scheduler_jobs.db)"
)
except ImportError as e:
logger.warning("APScheduler/SQLAlchemy non installe : %s", e)
return None
return _scheduler
def _envoyer_email_differe(destinataire: str, sujet: str, contenu: str) -> None:
"""Job interne appele par le scheduler : envoie reellement l'email."""
logger.info("Scheduler declenche : envoi a %s", destinataire)
# Appel direct de la logique send_email (sans le decorateur @tool)
send_email.invoke(
{"destinataire": destinataire, "sujet": sujet, "contenu": contenu}
)
@tool
def schedule_email(
destinataire: str, sujet: str, contenu: str, delay_minutes: int
) -> str:
"""
Programme l'envoi d'un email dans X minutes (envoi differe).
Utile pour : rappels, alertes planifiees, notifications differees.
L'utilisateur peut demander "envoie dans 2 minutes", "rappelle-moi dans 1h",
"programme un mail dans 30 minutes".
Args:
destinataire: Adresse email ou nom (Alice, P1...).
sujet: Sujet du mail.
contenu: Corps du mail en texte.
delay_minutes: Delai en minutes avant l'envoi (1 a 10080, soit 7 jours max).
Returns:
Confirmation avec l'heure prevue d'envoi.
"""
logger.info("Appel schedule_email vers %s dans %d min", destinataire, delay_minutes)
if delay_minutes < 1 or delay_minutes > 10080:
return "Le delai doit etre entre 1 minute et 7 jours (10080 min)."
# Resoudre le nom en email si besoin
if "@" not in destinataire:
resolved = TEAM_DIRECTORY.get(destinataire.strip().lower())
if resolved:
destinataire = resolved
scheduler = _get_scheduler()
if scheduler is None:
return (
"Scheduler indisponible (APScheduler non installe). "
"Executez : pip install apscheduler"
)
from datetime import datetime, timedelta
run_time = datetime.now() + timedelta(minutes=delay_minutes)
scheduler.add_job(
_envoyer_email_differe,
"date",
run_date=run_time,
args=[destinataire, sujet, contenu],
id=f"email_{run_time.timestamp()}",
)
heure_envoi = run_time.strftime("%H:%M:%S")
return (
f"Email programme pour {heure_envoi} (dans {delay_minutes} min) "
f"-> {destinataire} : {sujet}"
)
@tool
def cancel_scheduled_emails() -> str:
"""
Annule tous les emails programmes en attente dans le scheduler.
Utile si l'utilisateur a programme un email par erreur ou veut tout arreter.
Returns:
Nombre d'emails annules et confirmation.
"""
logger.info("Appel cancel_scheduled_emails")
scheduler = _get_scheduler()
if scheduler is None:
return "Scheduler indisponible (APScheduler non installe)."
jobs = scheduler.get_jobs()
if not jobs:
return "Aucun email programme en attente."
nb = len(jobs)
details = []
for job in jobs:
details.append(f" - {job.id} (prevu {job.next_run_time})")
job.remove()
return (
f"{nb} email(s) programme(s) annule(s) :\n"
+ "\n".join(details)
+ "\nTous les envois ont ete supprimes."
)
# ══════════════════════════════════════════════════════════════════
# OUTIL 8 — Prédiction ML du risque catastrophe (modèle EM-DAT multi-type)
# ══════════════════════════════════════════════════════════════════
_cached_predictions_country = None
_cached_predictions_detail = None
CLIMATE_TYPES = [
"drought",
"flood",
"extreme_weather",
"extreme_temperature",
"wildfire",
]
def _load_predictions() -> dict | None:
"""Charge les prédictions agrégées par pays (NB10).
L'agregat est recalcule a partir des predictions detail clippees
pour coherence (si clipping applique en detail, l'agregat est clippe aussi)."""
global _cached_predictions_country
if _cached_predictions_country is not None:
return _cached_predictions_country
# Recompose l'agregat depuis le detail clippe
detail = _load_predictions_detail()
if detail is not None:
_cached_predictions_country = {}
for key, data in detail.items():
total = sum(t["impact_pred"] for t in data["types"].values())
_cached_predictions_country[key] = {
"country": data["country"],
"continent": data["continent"],
"impact_pred": total,
}
logger.info(
"Prédictions ML (agrégat clippe) recomposees : %d pays",
len(_cached_predictions_country),
)
return _cached_predictions_country
# Fallback : CSV brut si detail indisponible
path = os.path.join("outputs", "NB10_predictions_2030_country.csv")
if not os.path.exists(path):
logger.warning("Prédictions ML non trouvées : %s", path)
return None
import csv
_cached_predictions_country = {}
with open(path, encoding="utf-8") as f:
reader = csv.DictReader(f)
for row in reader:
_cached_predictions_country[row["country"].lower()] = {
"country": row["country"],
"continent": row["continent"],
"impact_pred": float(row["impact_pred"]),
}
logger.info(
"Prédictions ML (agrégat) chargées : %d pays",
len(_cached_predictions_country),
)
return _cached_predictions_country
def _load_historical_max() -> dict:
"""Charge le max historique decadal par (pays, type) depuis EM-DAT.
Sert a clipper les predictions 2030 aberrantes (extrapolation warming trop forte).
"""
path = os.path.join("data", "decadal-deaths-disasters-by-type.csv")
if not os.path.exists(path):
return {}
import csv
maxima = {}
try:
with open(path, encoding="utf-8") as f:
reader = csv.DictReader(f)
for row in reader:
country = row.get("entity", "").lower()
for t in CLIMATE_TYPES:
col = f"total_dead_{t}_decadal"
try:
v = float(row.get(col) or 0)
except ValueError:
v = 0
key = (country, t)
if v > maxima.get(key, 0):
maxima[key] = v
except Exception as exc:
logger.warning("Impossible de charger max historique : %s", exc)
return maxima
def _load_predictions_detail() -> dict | None:
"""Charge les prédictions détaillées par (pays, type) (NB10)."""
global _cached_predictions_detail
if _cached_predictions_detail is not None:
return _cached_predictions_detail
path = os.path.join("outputs", "NB10_predictions_2030_detail.csv")
if not os.path.exists(path):
logger.warning("Prédictions ML détaillées non trouvées : %s", path)
return None
import csv
# Charge le max historique pour clipping des predictions aberrantes
hist_max = _load_historical_max()
clip_multiplier = 1.5 # tolerer +50% vs pire decennie historique
_cached_predictions_detail = {}
clip_count = 0
with open(path, encoding="utf-8") as f:
reader = csv.DictReader(f)
for row in reader:
key = row["country"].lower()
if key not in _cached_predictions_detail:
_cached_predictions_detail[key] = {
"country": row["country"],
"continent": row["continent"],
"types": {},
}
# Clipping anti-aberration : max 1.5x pire decennie historique
impact = float(row["impact_pred"])
hist_key = (key, row["disaster_type"])
hist_decadal_max = hist_max.get(hist_key, 0)
if hist_decadal_max > 0:
cap_annuel = (hist_decadal_max / 10) * clip_multiplier
if impact > cap_annuel:
impact = cap_annuel
clip_count += 1
_cached_predictions_detail[key]["types"][row["disaster_type"]] = {
"impact_pred": impact,
"risk_pred": row["risk_pred"],
}
if clip_count > 0:
logger.info(
"Clipping anti-aberration : %d predictions plafonnees (1.5x max historique)",
clip_count,
)
logger.info(
"Prédictions ML (détail) chargées : %d pays × %d types",
len(_cached_predictions_detail),
len(CLIMATE_TYPES),
)
return _cached_predictions_detail
def _resolve_country(country: str, predictions: dict) -> str | None:
"""Résout un nom de pays (tolère casse et correspondance partielle)."""
key = country.strip().lower()
if key in predictions:
return key
matches = [k for k in predictions if key in k or k in key]
return matches[0] if matches else None
@tool
def predict_risk(country: str) -> str:
"""
Prédit l'impact humain agrégé des catastrophes climatiques pour un pays
à l'horizon 2030, avec le détail par type (sécheresse, inondation,
tempête, canicule, feux de forêt). Basé sur un modèle ML entraîné sur
les données EM-DAT (1900-2020) en format multi-type, enrichi d'une
variable exogène de réchauffement global (NASA GISS).
Args:
country: Nom du pays en anglais (ex: "France", "India", "Bangladesh").
Returns:
Prédiction : impact total 2030 + détail par type de catastrophe
climatique + niveau de risque associé.
"""
logger.info("Appel predict_risk pour %s", country)
agg = _load_predictions()
detail = _load_predictions_detail()
if agg is None or detail is None:
return (
"Modèle ML non disponible. Lancez d'abord le notebook NB10 "
"pour générer outputs/NB10_predictions_2030_country.csv "
"et outputs/NB10_predictions_2030_detail.csv."
)
key = _resolve_country(country, agg)
if key is None:
pays_dispo = ", ".join(sorted(set(p["country"] for p in agg.values()))[:20])
return (
f"Pays « {country} » non trouvé dans les prédictions ML. "
f"Exemples disponibles : {pays_dispo}..."
)
pred = agg[key]
types_data = detail.get(key, {}).get("types", {})
lines = [
f"Prédiction ML 2030 pour {pred['country']} ({pred['continent']})",
f"- Impact total (tous types climatiques) : {pred['impact_pred']:.0f} décès/an",
"- Détail par type :",
]
for typ in CLIMATE_TYPES:
if typ in types_data:
t = types_data[typ]
lines.append(
f" {typ:<22} {t['impact_pred']:>8.0f} décès/an "
f"(risque : {t['risk_pred']})"
)
lines.append(
"- Source : modèle sklearn multi-type (5 types climatiques) entraîné "
"sur EM-DAT 1900-2020, avec feature exogène NASA GISS (réchauffement)."
)
lines.append(
"- Limite : prédiction statistique, ne tient pas compte des politiques "
"d'adaptation ni des projections climatiques physiques."
)
return "\n".join(lines)
@tool
def predict_risk_by_type(country: str, disaster_type: str) -> str:
"""
Prédit l'impact humain d'un type spécifique de catastrophe climatique
pour un pays à l'horizon 2030. Utile pour répondre aux questions
ciblées du style « quel est le risque d'inondation au Bangladesh ? ».
Args:
country: Nom du pays en anglais (ex: "Bangladesh").
disaster_type: Type de catastrophe parmi drought, flood,
extreme_weather, extreme_temperature, wildfire.
Returns:
Impact prédit 2030 pour ce type, niveau de risque, comparaison
avec les autres types climatiques du pays.
"""
logger.info("Appel predict_risk_by_type %s / %s", country, disaster_type)
detail = _load_predictions_detail()
if detail is None:
return (
"Modèle ML non disponible. Lancez d'abord le notebook NB10 "
"pour générer outputs/NB10_predictions_2030_detail.csv."
)
typ = disaster_type.strip().lower().replace(" ", "_")
if typ not in CLIMATE_TYPES:
return (
f"Type « {disaster_type} » non reconnu. "
f"Types disponibles : {', '.join(CLIMATE_TYPES)}."
)
key = _resolve_country(country, detail)
if key is None:
return f"Pays « {country} » non trouvé dans les prédictions ML."
pays_data = detail[key]
if typ not in pays_data["types"]:
return f"Pas de prédiction disponible pour {typ} en {pays_data['country']}."
t = pays_data["types"][typ]
# Ranking du type parmi les autres types du pays
tous = sorted(
pays_data["types"].items(),
key=lambda x: x[1]["impact_pred"],
reverse=True,
)
rang = [i for i, (nom, _) in enumerate(tous) if nom == typ][0] + 1
return (
f"Prédiction ML 2030 — {typ} en {pays_data['country']} "
f"({pays_data['continent']})\n"
f"- Impact prédit : {t['impact_pred']:.0f} décès/an\n"
f"- Niveau de risque : {t['risk_pred']}\n"
f"- Rang dans le pays : {rang}/{len(tous)} types climatiques\n"
f"- Source : modèle multi-type EM-DAT 1900-2020 + exogène "
f"réchauffement NASA GISS."
)
# ══════════════════════════════════════════════════════════════════
# OUTIL 9 — Score de risque agrégé multi-sources
# ══════════════════════════════════════════════════════════════════
_RISK_LEVELS = {
"Aucun": 0.0,
"Faible": 0.25,
"Modéré": 0.50,
"Élevé": 0.75,
"Critique": 1.0,
}
# Ponderation par defaut (horizon "standard" = 7 jours).
# Voir _POIDS_PAR_HORIZON pour les variantes court-terme / long-terme.
_POIDS = {
"meteo": 0.35,
"corpus": 0.25,
"ml_predict": 0.25,
"historique": 0.15,
}
# Ponderation dynamique selon l'horizon temporel de la decision.
# Court-terme (24-48h) : la meteo prime, ML et histo sont secondaires
# Standard (7 jours) : equilibre entre signal frais et contexte
# Long-terme (1-5 ans) : les projections ML + le corpus scientifique priment
_POIDS_PAR_HORIZON = {
"court_terme": {
"meteo": 0.50,
"ml_predict": 0.20,
"corpus": 0.20,
"historique": 0.10,
},
"standard": _POIDS, # 35/25/25/15 (defaut)
"long_terme": {
"meteo": 0.10,
"ml_predict": 0.40,
"corpus": 0.40,
"historique": 0.10,
},
}
@tool
def calculer_score_risque(
precipitation_prevue_mm: float,
seuil_critique_mm: float,
risk_level_ml: str,
a_precedent_historique: bool,
corpus_mentionne_risque: bool,
horizon: str = "standard",
) -> str:
"""
Calcule un score de risque agrégé (0-1) en croisant 4 sources :
météo (précipitations vs seuil), ML (prédiction EM-DAT),
corpus (GIEC mentionne un risque), historique (précédent connu).
La pondération s'adapte à l'horizon temporel de la décision :
- "court_terme" (24-48h) : météo 50 % + ML 20 % + corpus 20 % + histo 10 %
- "standard" (7 jours, défaut) : 35/25/25/15
- "long_terme" (1-5 ans) : ML 40 % + corpus 40 % + météo 10 % + histo 10 %
Args:
precipitation_prevue_mm: Précipitations prévues en mm.
seuil_critique_mm: Seuil critique du GIEC en mm.
risk_level_ml: Niveau de risque ML (Aucun/Faible/Modéré/Élevé/Critique).
a_precedent_historique: True si un événement similaire a eu lieu dans le passé.
corpus_mentionne_risque: True si le corpus GIEC mentionne un risque pour la zone.
horizon: "court_terme" / "standard" / "long_terme" (défaut "standard").
Returns:
Score agrégé avec détail par source et décision GO/NO-GO.
"""
logger.info(
"Calcul score risque : %.0fmm vs %.0fmm seuil, ML=%s, horizon=%s",
precipitation_prevue_mm,
seuil_critique_mm,
risk_level_ml,
horizon,
)
# Selection de la ponderation selon l'horizon (fallback standard si inconnu)
poids = _POIDS_PAR_HORIZON.get(horizon, _POIDS)
# Score météo : ratio précipitations / seuil (plafonné à 1.0)
if seuil_critique_mm > 0:
score_meteo = min(precipitation_prevue_mm / seuil_critique_mm, 1.0)
else:
score_meteo = 0.5
# Score ML
score_ml = _RISK_LEVELS.get(risk_level_ml, 0.5)
# Score corpus
score_corpus = 0.8 if corpus_mentionne_risque else 0.2
# Score historique
score_historique = 0.9 if a_precedent_historique else 0.1
# Agrégation pondérée selon l'horizon
score_final = (
poids["meteo"] * score_meteo
+ poids["ml_predict"] * score_ml
+ poids["corpus"] * score_corpus
+ poids["historique"] * score_historique
)
# Décision
if score_final >= 0.75:
decision = "CRITIQUE — Alerte immédiate recommandée"
elif score_final >= 0.50:
decision = "ÉLEVÉ — Vigilance renforcée"
elif score_final >= 0.25:
decision = "MODÉRÉ — Surveillance normale"
else:
decision = "FAIBLE — Pas d'action requise"
return (
f"Score de risque agrégé : {score_final:.2f} / 1.00 "
f"(horizon : {horizon})\n"
f"\nDétail par source (pondération {horizon}) :\n"
f" - Météo ({poids['meteo']:.0%}) : {score_meteo:.2f} "
f"({precipitation_prevue_mm:.0f}mm / {seuil_critique_mm:.0f}mm seuil)\n"
f" - ML EM-DAT ({poids['ml_predict']:.0%}) : {score_ml:.2f} "
f"(niveau {risk_level_ml})\n"
f" - Corpus GIEC ({poids['corpus']:.0%}) : {score_corpus:.2f} "
f"({'risque mentionné' if corpus_mentionne_risque else 'pas de mention'})\n"
f" - Historique ({poids['historique']:.0%}) : {score_historique:.2f} "
f"({'précédent connu' if a_precedent_historique else 'pas de précédent'})\n"
f"\nDécision : {decision}"
)
# ══════════════════════════════════════════════════════════════════
# OUTIL 10 — Inventaire du corpus RAG
# ══════════════════════════════════════════════════════════════════
@tool
def list_corpus() -> str:
"""
Liste tous les documents du corpus RAG avec leurs metadonnees.
Utilise cet outil quand l'utilisateur demande combien de documents
il y a, quels sont les documents disponibles, ou veut un inventaire
du corpus complet.
Returns:
Liste complete des fichiers PDF du corpus avec taille et nombre de pages.
"""
logger.info("Appel list_corpus")
# Lire le CSV pre-genere (rapide)
csv_path = os.path.join("outputs", "corpus_inventory.csv")
if os.path.exists(csv_path):
import csv
lines = ["Corpus SAEARCH :\n"]
total = 0
with open(csv_path, encoding="utf-8") as f:
reader = csv.DictReader(f)
for row in reader:
total += 1
lines.append(
f"{total}. {row['fichier']} "
f"({row['taille_mo']} Mo, {row['pages']} pages)"
)
lines.append(f"\nTotal : {total} documents")
return "\n".join(lines)
# Fallback : scan du dossier (sans compter les pages)
corpus_dir = os.path.join("data", "raw")
if not os.path.exists(corpus_dir):
return "Le dossier corpus (data/raw/) n'existe pas."
files = sorted(
f
for f in os.listdir(corpus_dir)
if f.lower().endswith((".pdf", ".docx", ".txt"))
)
if not files:
return "Aucun document trouve dans le corpus."
lines = [f"Corpus SAEARCH : {len(files)} documents\n"]
for i, f in enumerate(files, 1):
path = os.path.join(corpus_dir, f)
size_mb = os.path.getsize(path) / (1024 * 1024)
lines.append(f"{i}. {f} ({size_mb:.1f} Mo)")
return "\n".join(lines)
# ══════════════════════════════════════════════════════════════════
# Export : liste des outils pour l'agent LangGraph
# ══════════════════════════════════════════════════════════════════
ALL_TOOLS = [
get_weather,
get_historical_weather,
get_forecast,
web_search,
calculator,
search_corpus,
send_email,
send_bulk_email,
schedule_email,
cancel_scheduled_emails,
predict_risk,
predict_risk_by_type,
calculer_score_risque,
list_corpus,
]
# Initialisation EAGER du scheduler : au chargement du module tools,
# demarre le BackgroundScheduler. Sans cela, les jobs persistes dans
# scheduler_jobs.db ne s'executent pas tant que personne n'appelle
# schedule_email (donc les jobs en retard restent orphelins).
try:
_get_scheduler()
logger.info("Scheduler initialise au chargement de tools.py (eager)")
except Exception as _e:
logger.warning("Init eager scheduler impossible : %s", _e)
"""
Outils pour l'agent LangGraph Agentic RAG.
7 outils :
1. get_weather → météo actuelle (OpenMeteo)
2. get_historical_weather → météo historique (OpenMeteo Archive)
3. get_forecast → prévisions météo 7 jours (OpenMeteo)
4. web_search → recherche web (Tavily + DuckDuckGo fallback)
5. calculator → calculs mathématiques
6. search_corpus → recherche hybride dans le corpus RAG (BM25 + Dense)
7. send_email → envoi d'email d'alerte climatique
"""
import logging
import math
import os
import re
import requests
from duckduckgo_search import DDGS
from langchain_core.tools import tool
from src.config import (
METEO_FORECAST_DAYS,
OPENMETEO_BASE_URL,
OPENMETEO_GEOCODING_URL,
)
logger = logging.getLogger(__name__)
# ══════════════════════════════════════════════════════════════════
# UTILITAIRE — Géocodage (partagé entre les 3 outils météo)
# ══════════════════════════════════════════════════════════════════
_WMO_CODES: dict[int, str] = {
0: "Ciel dégagé",
1: "Principalement dégagé",
2: "Partiellement nuageux",
3: "Couvert",
45: "Brouillard",
48: "Brouillard givrant",
51: "Bruine légère",
53: "Bruine modérée",
55: "Bruine dense",
61: "Pluie légère",
63: "Pluie modérée",
65: "Pluie forte",
71: "Neige légère",
73: "Neige modérée",
75: "Neige forte",
77: "Grains de neige",
80: "Averses légères",
81: "Averses modérées",
82: "Averses violentes",
85: "Averses de neige",
86: "Averses de neige fortes",
95: "Orage",
96: "Orage avec grêle",
99: "Orage violent avec grêle",
}
def _geocode(city: str) -> tuple[float, float, str] | None:
"""Géocode une ville via l'API gratuite Open-Meteo geocoding."""
try:
resp = requests.get(
OPENMETEO_GEOCODING_URL,
params={"name": city, "count": 1, "language": "fr"},
timeout=10,
)
resp.raise_for_status()
results = resp.json().get("results", [])
if not results:
return None
r = results[0]
return r["latitude"], r["longitude"], r.get("name", city)
except Exception:
return None
# ══════════════════════════════════════════════════════════════════
# OUTIL 1 — Météo actuelle (OpenMeteo)
# ══════════════════════════════════════════════════════════════════
def get_weather(city: str) -> str:
"""
Récupère la météo actuelle d'une ville via l'API OpenMeteo (gratuit, sans clé).
Args:
city: Nom de la ville (ex: "Paris", "Lyon", "Bogota")
Returns:
Résumé météo : conditions, température, humidité, vent, précipitations.
"""
logger.info("Appel get_weather pour %s", city)
geo = _geocode(city)
if geo is None:
return f"Impossible de trouver la ville « {city} »."