bruno
eda4faeb78
- process_image_pipeline: wrapped in try/finally to guarantee processing_status is always updated, even on unexpected crashes/timeouts - init_db: recovery query that marks images stuck in 'processing' for >10min as ERROR on startup - Clean rewrite of pipeline.py for consistent indentation
263 lines
12 KiB
Python
263 lines
12 KiB
Python
"""
|
|
Pipeline de traitement AI — orchestration des 3 étapes
|
|
Chaque étape est indépendante : un échec partiel n'arrête pas le pipeline.
|
|
|
|
Publie des événements Redis (si disponible) pour le suivi en temps réel.
|
|
"""
|
|
import json
|
|
import logging
|
|
import time
|
|
from datetime import datetime, timezone
|
|
from typing import Any
|
|
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
from sqlalchemy import select
|
|
|
|
from app.models.image import Image, ProcessingStatus
|
|
from app.services.exif_service import extract_exif
|
|
from app.services.ocr_service import extract_text
|
|
from app.services.ai_vision import analyze_image, extract_text_with_ai
|
|
from app.metrics import (
|
|
hub_pipeline_duration, hub_pipeline_step_duration, hub_pipeline_errors,
|
|
hub_ai_tokens_consumed
|
|
)
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
async def _publish_event(
|
|
redis: Any, image_id: int, event: str, data: dict | None = None
|
|
) -> None:
|
|
"""
|
|
Publie un événement sur le channel Redis pipeline:{image_id}.
|
|
|
|
Stocke aussi les 10 derniers événements dans un buffer Redis
|
|
(clé pipeline:buffer:{image_id}, TTL 60s) pour la reconnexion WebSocket.
|
|
Publie sur pipeline:admin pour le monitoring admin.
|
|
"""
|
|
if redis is None:
|
|
return
|
|
try:
|
|
payload = {"event": event, "image_id": image_id, "timestamp": time.time()}
|
|
if data:
|
|
payload["data"] = data
|
|
raw = json.dumps(payload)
|
|
|
|
await redis.publish(f"pipeline:{image_id}", raw)
|
|
|
|
buffer_key = f"pipeline:buffer:{image_id}"
|
|
await redis.rpush(buffer_key, raw)
|
|
await redis.ltrim(buffer_key, -10, -1)
|
|
await redis.expire(buffer_key, 60)
|
|
|
|
if event in ("pipeline.started", "pipeline.done", "pipeline.error"):
|
|
await redis.publish("pipeline:admin", raw)
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
async def process_image_pipeline(
|
|
image_id: int, db: AsyncSession, redis: Any = None
|
|
) -> None:
|
|
"""
|
|
Pipeline complet de traitement d'une image :
|
|
1. Extraction EXIF (async)
|
|
2. OCR — extraction texte (async)
|
|
3. Vision AI — description + tags (async)
|
|
4. Sauvegarde finale en BDD
|
|
|
|
Try/finally garantit que le statut est TOUJOURS mis à jour,
|
|
même en cas de crash inattendu (timeout, OOM, etc.).
|
|
"""
|
|
result = await db.execute(select(Image).where(Image.id == image_id))
|
|
image = result.scalar_one_or_none()
|
|
|
|
if not image:
|
|
logger.warning("pipeline.image_not_found", extra={"image_id": image_id})
|
|
return
|
|
|
|
image.processing_status = ProcessingStatus.PROCESSING
|
|
image.processing_started_at = datetime.now(timezone.utc)
|
|
t_start = time.time()
|
|
await db.commit()
|
|
await db.refresh(image)
|
|
|
|
await _publish_event(redis, image_id, "pipeline.started")
|
|
|
|
errors: list[str] = []
|
|
file_path = image.file_path
|
|
|
|
try:
|
|
# ════════════════════════════════════════════════════════
|
|
# ÉTAPE 1 — Extraction EXIF
|
|
# ════════════════════════════════════════════════════════
|
|
try:
|
|
logger.info("pipeline.step.start", extra={"image_id": image_id, "step": "exif", "step_num": "1/3"})
|
|
t0 = time.time()
|
|
|
|
exif = await extract_exif(file_path)
|
|
|
|
image.exif_raw = exif.get("raw")
|
|
image.exif_make = exif.get("make")
|
|
image.exif_model = exif.get("model")
|
|
image.exif_lens = exif.get("lens")
|
|
image.exif_taken_at = exif.get("taken_at")
|
|
image.exif_gps_lat = exif.get("gps_lat")
|
|
image.exif_gps_lon = exif.get("gps_lon")
|
|
image.exif_altitude = exif.get("altitude")
|
|
image.exif_iso = exif.get("iso")
|
|
image.exif_aperture = exif.get("aperture")
|
|
image.exif_shutter = exif.get("shutter")
|
|
image.exif_focal = exif.get("focal")
|
|
image.exif_flash = exif.get("flash")
|
|
image.exif_orientation = exif.get("orientation")
|
|
image.exif_software = exif.get("software")
|
|
|
|
await db.commit()
|
|
elapsed = int((time.time() - t0) * 1000)
|
|
hub_pipeline_step_duration.labels(step="exif").observe(time.time() - t0)
|
|
|
|
logger.info("pipeline.step.done", extra={"image_id": image_id, "step": "exif", "duration_ms": elapsed, "camera": image.exif_make})
|
|
await _publish_event(redis, image_id, "step.completed", {
|
|
"step": "exif", "duration_ms": elapsed, "camera": image.exif_make,
|
|
})
|
|
|
|
except Exception as e:
|
|
msg = f"EXIF : {str(e)}"
|
|
errors.append(msg)
|
|
hub_pipeline_errors.labels(step="exif").inc()
|
|
logger.error("pipeline.step.error", extra={"image_id": image_id, "step": "exif", "error": str(e)})
|
|
|
|
# ════════════════════════════════════════════════════════
|
|
# ÉTAPE 2 — OCR
|
|
# ════════════════════════════════════════════════════════
|
|
try:
|
|
logger.info("pipeline.step.start", extra={"image_id": image_id, "step": "ocr", "step_num": "2/3"})
|
|
t0 = time.time()
|
|
|
|
ocr = await extract_text(file_path)
|
|
|
|
if not ocr.get("has_text", False):
|
|
logger.info("pipeline.ocr.fallback", extra={"image_id": image_id, "reason": "tesseract_empty"})
|
|
ai_ocr = await extract_text_with_ai(file_path)
|
|
|
|
if ai_ocr.get("has_text"):
|
|
ocr = ai_ocr
|
|
logger.info("pipeline.ocr.fallback_success", extra={"image_id": image_id, "chars": len(ocr.get("text", ""))})
|
|
else:
|
|
logger.info("pipeline.ocr.fallback_empty", extra={"image_id": image_id})
|
|
|
|
image.ocr_text = ocr.get("text")
|
|
image.ocr_language = ocr.get("language")
|
|
image.ocr_confidence = ocr.get("confidence")
|
|
image.ocr_has_text = ocr.get("has_text", False)
|
|
|
|
await db.commit()
|
|
elapsed = int((time.time() - t0) * 1000)
|
|
hub_pipeline_step_duration.labels(step="ocr").observe(time.time() - t0)
|
|
|
|
logger.info("pipeline.step.done", extra={"image_id": image_id, "step": "ocr", "duration_ms": elapsed, "has_text": image.ocr_has_text})
|
|
await _publish_event(redis, image_id, "step.completed", {
|
|
"step": "ocr", "duration_ms": elapsed, "has_text": image.ocr_has_text,
|
|
})
|
|
|
|
except Exception as e:
|
|
msg = f"OCR : {str(e)}"
|
|
errors.append(msg)
|
|
hub_pipeline_errors.labels(step="ocr").inc()
|
|
logger.error("pipeline.step.error", extra={"image_id": image_id, "step": "ocr", "error": str(e)})
|
|
|
|
# ════════════════════════════════════════════════════════
|
|
# ÉTAPE 3 — Vision AI (description + tags)
|
|
# ════════════════════════════════════════════════════════
|
|
try:
|
|
logger.info("pipeline.step.start", extra={"image_id": image_id, "step": "ai", "step_num": "3/3"})
|
|
t0 = time.time()
|
|
|
|
provider_override = None
|
|
model_override = None
|
|
if image.client_id:
|
|
from app.models.client import APIClient
|
|
client_result = await db.execute(
|
|
select(APIClient).where(APIClient.id == image.client_id)
|
|
)
|
|
owner = client_result.scalar_one_or_none()
|
|
if owner:
|
|
provider_override = owner.ai_provider
|
|
model_override = owner.ai_model
|
|
|
|
ai = await analyze_image(
|
|
file_path=file_path,
|
|
ocr_hint=image.ocr_text,
|
|
provider_override=provider_override,
|
|
model_override=model_override,
|
|
)
|
|
|
|
image.ai_description = ai.get("description")
|
|
image.ai_tags = ai.get("tags", [])
|
|
image.ai_confidence = ai.get("confidence")
|
|
image.ai_model_used = ai.get("model")
|
|
image.ai_processed_at = datetime.now(timezone.utc)
|
|
image.ai_prompt_tokens = ai.get("prompt_tokens")
|
|
image.ai_output_tokens = ai.get("output_tokens")
|
|
|
|
await db.commit()
|
|
elapsed = int((time.time() - t0) * 1000)
|
|
hub_pipeline_step_duration.labels(step="ai").observe(time.time() - t0)
|
|
|
|
if image.ai_prompt_tokens or image.ai_output_tokens:
|
|
total_tokens = (image.ai_prompt_tokens or 0) + (image.ai_output_tokens or 0)
|
|
hub_ai_tokens_consumed.labels(
|
|
client_id=image.client_id,
|
|
model=image.ai_model_used or "unknown"
|
|
).inc(total_tokens)
|
|
|
|
logger.info("pipeline.step.done", extra={"image_id": image_id, "step": "ai", "duration_ms": elapsed, "tags_count": len(image.ai_tags or [])})
|
|
await _publish_event(redis, image_id, "step.completed", {
|
|
"step": "ai", "duration_ms": elapsed, "tags_count": len(image.ai_tags or []),
|
|
})
|
|
|
|
except Exception as e:
|
|
msg = f"AI Vision : {str(e)}"
|
|
errors.append(msg)
|
|
hub_pipeline_errors.labels(step="ai").inc()
|
|
logger.error("pipeline.step.error", extra={"image_id": image_id, "step": "ai", "error": str(e)})
|
|
|
|
finally:
|
|
# ════════════════════════════════════════════════════════
|
|
# FINALISATION — toujours exécuté, même après un crash
|
|
# ════════════════════════════════════════════════════════
|
|
try:
|
|
image.processing_done_at = datetime.now(timezone.utc)
|
|
|
|
if errors:
|
|
if image.ai_description:
|
|
image.processing_status = ProcessingStatus.DONE
|
|
image.processing_error = f"Avertissements : {'; '.join(errors)}"
|
|
else:
|
|
image.processing_status = ProcessingStatus.ERROR
|
|
image.processing_error = "; ".join(errors)
|
|
else:
|
|
image.processing_status = ProcessingStatus.DONE
|
|
image.processing_error = None
|
|
|
|
await db.commit()
|
|
hub_pipeline_duration.observe(time.time() - t_start)
|
|
|
|
logger.info("pipeline.completed", extra={
|
|
"image_id": image_id,
|
|
"status": image.processing_status.value,
|
|
"errors": len(errors),
|
|
})
|
|
|
|
if errors:
|
|
await _publish_event(redis, image_id, "pipeline.error", {"errors": errors})
|
|
else:
|
|
await _publish_event(redis, image_id, "pipeline.done")
|
|
except Exception as final_error:
|
|
# Si même la finalisation échoue, log seulement — ne pas laisser l'image bloquée
|
|
logger.critical("pipeline.finalization_failed", extra={
|
|
"image_id": image_id,
|
|
"error": str(final_error),
|
|
})
|