469 lines
14 KiB
Python
469 lines
14 KiB
Python
"""
|
|
Service AI Vision — description, classification et tags via Google Gemini ou OpenRouter.
|
|
|
|
Résilience :
|
|
- Timeout configurable (AI_REQUEST_TIMEOUT)
|
|
- Retry avec backoff exponentiel (AI_MAX_RETRIES)
|
|
- Client Gemini non-singleton (recréé si la clé change)
|
|
"""
|
|
import asyncio
|
|
import json
|
|
import logging
|
|
import re
|
|
import base64
|
|
import time
|
|
import httpx
|
|
import io
|
|
from pathlib import Path
|
|
from typing import Optional, Tuple
|
|
|
|
from google import genai
|
|
from google.genai import types
|
|
|
|
from app.config import settings
|
|
from app.services.storage_backend import get_storage_backend
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
# Cache du client Gemini avec TTL (évite de recréer à chaque appel)
|
|
_client: Optional[genai.Client] = None
|
|
_client_api_key: Optional[str] = None
|
|
|
|
|
|
def _get_client() -> genai.Client:
|
|
"""Retourne un client Gemini. Recrée si la clé API a changé."""
|
|
global _client, _client_api_key
|
|
current_key = settings.GEMINI_API_KEY
|
|
if _client is None or _client_api_key != current_key:
|
|
_client = genai.Client(api_key=current_key)
|
|
_client_api_key = current_key
|
|
return _client
|
|
|
|
|
|
async def _read_image(file_path: str) -> tuple[bytes, str]:
|
|
"""Lit l'image via le StorageBackend et détecte le media_type."""
|
|
path = Path(file_path)
|
|
suffix = path.suffix.lower()
|
|
|
|
mime_map = {
|
|
".jpg": "image/jpeg",
|
|
".jpeg": "image/jpeg",
|
|
".png": "image/png",
|
|
".gif": "image/gif",
|
|
".webp": "image/webp",
|
|
}
|
|
media_type = mime_map.get(suffix, "image/jpeg")
|
|
|
|
backend = get_storage_backend()
|
|
data = await backend.get_bytes(file_path)
|
|
return data, media_type
|
|
|
|
|
|
def _extract_json(text: str) -> Optional[dict]:
|
|
cleaned = re.sub(r"```json\s*|```\s*", "", (text or "")).strip()
|
|
json_match = re.search(r"\{.*\}", cleaned, re.DOTALL)
|
|
if not json_match:
|
|
return None
|
|
try:
|
|
return json.loads(json_match.group())
|
|
except json.JSONDecodeError:
|
|
return None
|
|
|
|
|
|
def _usage_tokens_gemini(response) -> tuple[Optional[int], Optional[int]]:
|
|
usage = getattr(response, "usage_metadata", None)
|
|
if not usage:
|
|
return None, None
|
|
prompt_tokens = getattr(usage, "prompt_token_count", None)
|
|
output_tokens = getattr(usage, "candidates_token_count", None)
|
|
return prompt_tokens, output_tokens
|
|
|
|
|
|
async def _retry_with_backoff(fn, *args, max_retries=None, **kwargs):
|
|
"""Exécute fn avec retry + backoff exponentiel en cas d'échec."""
|
|
retries = max_retries if max_retries is not None else settings.AI_MAX_RETRIES
|
|
last_error = None
|
|
|
|
for attempt in range(retries + 1):
|
|
try:
|
|
return await fn(*args, **kwargs)
|
|
except asyncio.TimeoutError:
|
|
last_error = "timeout"
|
|
wait = 2 ** attempt
|
|
logger.warning("ai.retry.timeout", extra={
|
|
"attempt": attempt + 1,
|
|
"max_retries": retries,
|
|
"wait_s": wait,
|
|
})
|
|
except Exception as e:
|
|
last_error = str(e)
|
|
wait = 2 ** attempt
|
|
logger.warning("ai.retry.error", extra={
|
|
"attempt": attempt + 1,
|
|
"max_retries": retries,
|
|
"wait_s": wait,
|
|
"error": str(e),
|
|
})
|
|
if attempt < retries:
|
|
await asyncio.sleep(wait)
|
|
|
|
raise Exception(f"AI request failed after {retries + 1} attempts: {last_error}")
|
|
|
|
|
|
async def _generate_gemini(
|
|
prompt: str,
|
|
image_bytes: Optional[bytes] = None,
|
|
media_type: Optional[str] = None,
|
|
max_tokens: int = 1024
|
|
) -> dict:
|
|
"""Appel à Google Gemini via SDK avec timeout et retry."""
|
|
if not settings.GEMINI_API_KEY:
|
|
logger.warning("ai.gemini.no_key")
|
|
return {"text": None, "usage": (None, None)}
|
|
|
|
client = _get_client()
|
|
contents = []
|
|
if image_bytes and media_type:
|
|
contents.append(types.Part.from_bytes(data=image_bytes, mime_type=media_type))
|
|
contents.append(prompt)
|
|
|
|
async def _call():
|
|
return await asyncio.wait_for(
|
|
asyncio.to_thread(
|
|
client.models.generate_content,
|
|
model=settings.GEMINI_MODEL,
|
|
contents=contents,
|
|
config=types.GenerateContentConfig(
|
|
max_output_tokens=max_tokens,
|
|
response_mime_type="application/json",
|
|
),
|
|
),
|
|
timeout=settings.AI_REQUEST_TIMEOUT,
|
|
)
|
|
|
|
try:
|
|
response = await _retry_with_backoff(_call)
|
|
usage = _usage_tokens_gemini(response)
|
|
return {"text": getattr(response, "text", ""), "usage": usage}
|
|
except Exception as e:
|
|
logger.error("ai.gemini.error", extra={"error": str(e)})
|
|
return {"text": None, "usage": (None, None), "error": str(e)}
|
|
|
|
|
|
async def _generate_openrouter(
|
|
prompt: str,
|
|
image_bytes: Optional[bytes] = None,
|
|
media_type: Optional[str] = None,
|
|
max_tokens: int = 1024
|
|
) -> dict:
|
|
"""Appel à OpenRouter via HTTP avec timeout et retry."""
|
|
if not settings.OPENROUTER_API_KEY:
|
|
logger.warning("ai.openrouter.no_key")
|
|
return {"text": None, "usage": (None, None)}
|
|
|
|
headers = {
|
|
"Authorization": f"Bearer {settings.OPENROUTER_API_KEY}",
|
|
"Content-Type": "application/json",
|
|
"HTTP-Referer": settings.HOST,
|
|
"X-Title": settings.APP_NAME,
|
|
}
|
|
|
|
messages = []
|
|
content_payload = []
|
|
content_payload.append({"type": "text", "text": prompt})
|
|
|
|
if image_bytes and media_type:
|
|
b64_img = base64.b64encode(image_bytes).decode("utf-8")
|
|
content_payload.append({
|
|
"type": "image_url",
|
|
"image_url": {
|
|
"url": f"data:{media_type};base64,{b64_img}"
|
|
}
|
|
})
|
|
|
|
messages.append({"role": "user", "content": content_payload})
|
|
|
|
payload = {
|
|
"model": settings.OPENROUTER_MODEL,
|
|
"messages": messages,
|
|
"max_tokens": max_tokens,
|
|
"response_format": {"type": "json_object"}
|
|
}
|
|
|
|
async def _call():
|
|
async with httpx.AsyncClient() as client:
|
|
response = await client.post(
|
|
"https://openrouter.ai/api/v1/chat/completions",
|
|
json=payload,
|
|
headers=headers,
|
|
timeout=settings.AI_REQUEST_TIMEOUT,
|
|
)
|
|
response.raise_for_status()
|
|
return response.json()
|
|
|
|
try:
|
|
data = await _retry_with_backoff(_call)
|
|
text = ""
|
|
if "choices" in data and len(data["choices"]) > 0:
|
|
text = data["choices"][0]["message"]["content"]
|
|
|
|
usage_data = data.get("usage", {})
|
|
prompt_tokens = usage_data.get("prompt_tokens")
|
|
output_tokens = usage_data.get("completion_tokens")
|
|
|
|
return {"text": text, "usage": (prompt_tokens, output_tokens)}
|
|
|
|
except Exception as e:
|
|
logger.error("ai.openrouter.error", extra={"error": str(e)})
|
|
return {"text": None, "usage": (None, None), "error": str(e)}
|
|
|
|
|
|
async def _generate(
|
|
prompt: str,
|
|
image_bytes: Optional[bytes] = None,
|
|
media_type: Optional[str] = None,
|
|
max_tokens: int = 1024
|
|
) -> dict:
|
|
"""Dispatcher vers le bon provider."""
|
|
provider = settings.AI_PROVIDER.lower()
|
|
logger.info("ai.generate", extra={"provider": provider})
|
|
|
|
if provider == "openrouter":
|
|
return await _generate_openrouter(prompt, image_bytes, media_type, max_tokens)
|
|
else:
|
|
return await _generate_gemini(prompt, image_bytes, media_type, max_tokens)
|
|
|
|
|
|
def _build_prompt(ocr_hint: Optional[str], language: str) -> str:
|
|
ocr_section = ""
|
|
if ocr_hint and len(ocr_hint.strip()) > 5:
|
|
ocr_section = f"""
|
|
Texte détecté dans l'image par OCR (utilise-le pour enrichir ta réponse) :
|
|
\"\"\"
|
|
{ocr_hint[:500]}
|
|
\"\"\"
|
|
"""
|
|
|
|
return f"""Analyse cette image avec précision et retourne UNIQUEMENT un objet JSON valide avec ces champs :
|
|
|
|
{{
|
|
"description": "Description complète et détaillée en {language}, 2-4 phrases. Décris le sujet principal, le contexte, les couleurs, l'ambiance.",
|
|
"tags": ["tag1", "tag2", "tag3"],
|
|
"confidence": 0.95
|
|
}}
|
|
|
|
Règles pour les tags :
|
|
- Entre {settings.AI_TAGS_MIN} et {settings.AI_TAGS_MAX} tags
|
|
- En minuscules, sans espaces (utiliser des tirets si nécessaire)
|
|
- Couvrir : sujet principal, type d'image, couleurs dominantes, style, contexte
|
|
- Exemples : portrait, paysage, architecture, nature, nourriture, texte, document, animal, sport, technologie, intérieur, extérieur
|
|
{ocr_section}
|
|
Réponds UNIQUEMENT avec le JSON, sans texte avant ou après, sans balises markdown."""
|
|
|
|
|
|
async def analyze_image(
|
|
file_path: str,
|
|
ocr_hint: Optional[str] = None,
|
|
language: str = "français",
|
|
) -> dict:
|
|
"""
|
|
Envoie l'image à l'AI pour analyse (Description + Tags).
|
|
"""
|
|
if not settings.AI_ENABLED:
|
|
return {}
|
|
|
|
result = {
|
|
"description": None,
|
|
"tags": [],
|
|
"confidence": None,
|
|
"model": settings.OPENROUTER_MODEL if settings.AI_PROVIDER == "openrouter" else settings.GEMINI_MODEL,
|
|
"prompt_tokens": None,
|
|
"output_tokens": None,
|
|
}
|
|
|
|
try:
|
|
image_bytes, media_type = await _read_image(file_path)
|
|
prompt = _build_prompt(ocr_hint, language)
|
|
|
|
response = await _generate(
|
|
prompt=prompt,
|
|
image_bytes=image_bytes,
|
|
media_type=media_type,
|
|
max_tokens=settings.GEMINI_MAX_TOKENS
|
|
)
|
|
|
|
text = response.get("text")
|
|
result["prompt_tokens"], result["output_tokens"] = response.get("usage")
|
|
|
|
if text:
|
|
parsed = _extract_json(text)
|
|
if parsed:
|
|
result["description"] = parsed.get("description")
|
|
result["tags"] = parsed.get("tags", [])
|
|
result["confidence"] = parsed.get("confidence")
|
|
else:
|
|
logger.warning("ai.vision.json_parse_failed", extra={"raw": text[:100]})
|
|
|
|
if response.get("error"):
|
|
logger.error("ai.vision.provider_error", extra={"error": response["error"]})
|
|
|
|
except Exception as e:
|
|
logger.error("ai.vision.unexpected_error", extra={"error": str(e)})
|
|
|
|
return result
|
|
|
|
|
|
async def extract_text_with_ai(file_path: str) -> dict:
|
|
"""
|
|
Utilise l'AI comme fallback OCR.
|
|
"""
|
|
result = {
|
|
"text": None,
|
|
"has_text": False,
|
|
"language": "unknown",
|
|
"confidence": 0.0,
|
|
"method": f"ai-{settings.AI_PROVIDER}"
|
|
}
|
|
|
|
if not settings.AI_ENABLED:
|
|
return result
|
|
|
|
logger.info("ai.ocr.fallback_start", extra={"file": Path(file_path).name})
|
|
|
|
try:
|
|
image_bytes, media_type = await _read_image(file_path)
|
|
prompt = """Agis comme un moteur OCR avancé.
|
|
Extrais TOUT le texte visible dans cette image.
|
|
Retourne UNIQUEMENT un objet JSON :
|
|
{
|
|
"text": "Le texte complet extrait ici...",
|
|
"language": "fr" (code langue ISO 2 lettres, ex: fr, en, es),
|
|
"confidence": 0.9 (estimation confiance 0.0 à 1.0)
|
|
}
|
|
Si aucun texte n'est visible, retourne : {"text": "", "has_text": false}
|
|
"""
|
|
|
|
response = await _generate(
|
|
prompt=prompt,
|
|
image_bytes=image_bytes,
|
|
media_type=media_type,
|
|
max_tokens=1024
|
|
)
|
|
|
|
text = response.get("text")
|
|
if text:
|
|
parsed = _extract_json(text)
|
|
if parsed:
|
|
extracted = parsed.get("text", "").strip()
|
|
result["text"] = extracted
|
|
result["has_text"] = bool(extracted) or parsed.get("has_text", False)
|
|
result["language"] = parsed.get("language", "unknown")
|
|
result["confidence"] = parsed.get("confidence", 0.0)
|
|
logger.info("ai.ocr.success", extra={"chars": len(extracted)})
|
|
else:
|
|
logger.warning("ai.ocr.json_parse_failed")
|
|
else:
|
|
logger.info("ai.ocr.empty_response")
|
|
|
|
except Exception as e:
|
|
logger.error("ai.ocr.error", extra={"error": str(e)})
|
|
|
|
return result
|
|
|
|
|
|
async def summarize_url(url: str, content: str, language: str = "français") -> dict:
|
|
"""Génère un résumé et des tags pour un contenu web."""
|
|
result = {
|
|
"summary": "",
|
|
"tags": [],
|
|
"model": settings.AI_PROVIDER,
|
|
"prompt_tokens": None,
|
|
"output_tokens": None,
|
|
}
|
|
|
|
if not settings.AI_ENABLED:
|
|
return result
|
|
|
|
prompt = f"""Tu reçois le contenu d'une page web. Génère un résumé et des tags en {language}.
|
|
|
|
URL : {url}
|
|
|
|
Contenu :
|
|
\"\"\"
|
|
{content[:3000]}
|
|
\"\"\"
|
|
|
|
Retourne UNIQUEMENT ce JSON :
|
|
{{
|
|
"summary": "Résumé clair en 3-5 phrases en {language}",
|
|
"tags": ["tag1", "tag2", "tag3"]
|
|
}}"""
|
|
|
|
try:
|
|
response = await _generate(
|
|
prompt=prompt,
|
|
max_tokens=settings.GEMINI_MAX_TOKENS
|
|
)
|
|
|
|
text = response.get("text")
|
|
if text:
|
|
parsed = _extract_json(text)
|
|
if parsed:
|
|
result["summary"] = parsed.get("summary", "")
|
|
result["tags"] = parsed.get("tags", [])
|
|
result["prompt_tokens"], result["output_tokens"] = response.get("usage")
|
|
|
|
except Exception as e:
|
|
logger.error("ai.summarize_url.error", extra={"error": str(e)})
|
|
|
|
return result
|
|
|
|
|
|
async def draft_task(description: str, context: Optional[str], language: str = "français") -> dict:
|
|
"""Génère une tâche structurée à partir d'une description."""
|
|
result = {
|
|
"title": "",
|
|
"description": "",
|
|
"steps": [],
|
|
"estimated_time": None,
|
|
"priority": None,
|
|
"model": settings.AI_PROVIDER,
|
|
"prompt_tokens": None,
|
|
"output_tokens": None,
|
|
}
|
|
|
|
if not settings.AI_ENABLED:
|
|
return result
|
|
|
|
ctx_section = f"\nContexte : {context}" if context else ""
|
|
prompt = f"""Tu es un assistant de gestion de tâches. Génère une tâche structurée en {language}.
|
|
|
|
Description : {description}{ctx_section}
|
|
|
|
Retourne UNIQUEMENT ce JSON :
|
|
{{
|
|
"title": "Titre court et actionnable",
|
|
"description": "Description complète de la tâche",
|
|
"steps": ["Étape 1", "Étape 2", "Étape 3"],
|
|
"estimated_time": "30 minutes",
|
|
"priority": "haute|moyenne|basse"
|
|
}}"""
|
|
|
|
try:
|
|
response = await _generate(
|
|
prompt=prompt,
|
|
max_tokens=settings.GEMINI_MAX_TOKENS
|
|
)
|
|
|
|
text = response.get("text")
|
|
if text:
|
|
parsed = _extract_json(text)
|
|
if parsed:
|
|
result.update(parsed)
|
|
result["prompt_tokens"], result["output_tokens"] = response.get("usage")
|
|
|
|
except Exception as e:
|
|
logger.error("ai.draft_task.error", extra={"error": str(e)})
|
|
|
|
return result
|