fix: 3 production bugs — mistralai import, page ID collision, provider logging

BUG 1 (ImportError mistralai): wrap `from mistralai import Mistral` in
try/except ImportError with a clear message pointing to `pip install
'mistralai>=1.0'`. pyproject.toml already pins >=1.0.

BUG 2 (UNIQUE constraint failed pages.id): two fixes:
A) _create_page now checks if page ID exists before INSERT — returns None
if already present (skip with log). All 3 ingestion endpoints track
created vs skipped and return pages_skipped in IngestResponse.
B) New _make_page_id helper adds sequence number to ID when folio_label
is not unique in the batch: {slug}-{seq:04d}-{label}. Prevents
collision when multiple canvases share the same label (e.g. "NP").
Added 3 tests: reingest manifest, reingest images, duplicate labels.

BUG 3 (Provider inaccessible): log messages in get_available_providers and
list_all_models now include provider name and error in the message string
itself (not only in extras), for better readability in HF logs.

https://claude.ai/code/session_018woyEHc8HG2th7V4ewJ4Kg

backend/app/api/v1/ingest.py

@@ -46,6 +46,7 @@ class IngestResponse(BaseModel):
     corpus_id: str
     manuscript_id: str
     pages_created: int
+    pages_skipped: int = 0
     page_ids: list[str]
 
 
@@ -92,16 +93,37 @@ async def _next_sequence(db: AsyncSession, manuscript_id: str) -> int:
     return (max_seq or 0) + 1
 
 
+def _find_duplicate_labels(labels: list[str]) -> set[str]:
+    """Retourne les folio_labels qui apparaissent plus d'une fois."""
+    seen: dict[str, int] = {}
+    for label in labels:
+        seen[label] = seen.get(label, 0) + 1
+    return {label for label, count in seen.items() if count > 1}
+
+
+def _make_page_id(corpus_slug: str, folio_label: str, batch_index: int, duplicate_labels: set[str]) -> str:
+    """Génère un ID de page.  Ajoute le batch_index si le label n'est pas unique."""
+    if folio_label in duplicate_labels:
+        return f"{corpus_slug}-{batch_index:04d}-{folio_label}"
+    return f"{corpus_slug}-{folio_label}"
+
+
 async def _create_page(
     db: AsyncSession,
     manuscript_id: str,
-    corpus_id: str,
+    page_id: str,
     folio_label: str,
     sequence: int,
     image_master_path: str | None = None,
-) -> PageModel:
+) -> PageModel | None:
+    """Crée une page si elle n'existe pas déjà.  Retourne None si l'ID est déjà pris."""
+    existing = await db.get(PageModel, page_id)
+    if existing is not None:
+        logger.info("Page déjà existante, ignorée", extra={"page_id": page_id})
+        return None
+
     page = PageModel(
-        id=f"{corpus_id}-{folio_label}",
+        id=page_id,
         manuscript_id=manuscript_id,
         folio_label=folio_label,
         sequence=sequence,
@@ -179,10 +201,16 @@ async def ingest_files(
     ms = await _get_or_create_manuscript(db, corpus_id)
     seq = await _next_sequence(db, ms.id)
 
+    # Collect labels and detect duplicates
+    labels = [Path(f.filename or f"file_{i}").stem for i, f in enumerate(files)]
+    dupes = _find_duplicate_labels(labels)
+
     created: list[PageModel] = []
+    skipped = 0
     for i, upload in enumerate(files):
         filename = Path(upload.filename or f"file_{i}").name
-        folio_label = Path(filename).stem  # nom sans extension
+        folio_label = labels[i]
+        page_id = _make_page_id(corpus.slug, folio_label, seq + i, dupes)
 
         master_dir = (
             _config_module.settings.data_dir
@@ -197,22 +225,26 @@ async def ingest_files(
         master_path.write_bytes(content)
 
         page = await _create_page(
-            db, ms.id, corpus.slug, folio_label, seq + i,
+            db, ms.id, page_id, folio_label, seq + i,
             image_master_path=str(master_path),
         )
-        created.append(page)
+        if page is None:
+            skipped += 1
+        else:
+            created.append(page)
 
     ms.total_pages = (ms.total_pages or 0) + len(created)
     await db.commit()
 
     logger.info(
         "Fichiers ingérés",
-        extra={"corpus_id": corpus_id, "count": len(created)},
+        extra={"corpus_id": corpus_id, "created": len(created), "skipped": skipped},
     )
     return IngestResponse(
         corpus_id=corpus_id,
         manuscript_id=ms.id,
         pages_created=len(created),
+        pages_skipped=skipped,
         page_ids=[p.id for p in created],
     )
 
@@ -269,27 +301,37 @@ async def ingest_iiif_manifest(
     ms = await _get_or_create_manuscript(db, corpus_id, title=ms_title)
     seq = await _next_sequence(db, ms.id)
 
+    # Collect labels and detect duplicates
+    labels = [_extract_canvas_label(canvas, i) for i, canvas in enumerate(canvases)]
+    dupes = _find_duplicate_labels(labels)
+
     created: list[PageModel] = []
+    skipped = 0
     for i, canvas in enumerate(canvases):
-        folio_label = _extract_canvas_label(canvas, i)
+        folio_label = labels[i]
+        page_id = _make_page_id(corpus.slug, folio_label, seq + i, dupes)
         image_url = _extract_canvas_image_url(canvas)
         page = await _create_page(
-            db, ms.id, corpus.slug, folio_label, seq + i,
+            db, ms.id, page_id, folio_label, seq + i,
             image_master_path=image_url,
         )
-        created.append(page)
+        if page is None:
+            skipped += 1
+        else:
+            created.append(page)
 
     ms.total_pages = (ms.total_pages or 0) + len(created)
     await db.commit()
 
     logger.info(
         "Manifest IIIF ingéré",
-        extra={"corpus_id": corpus_id, "url": body.manifest_url, "pages": len(created)},
+        extra={"corpus_id": corpus_id, "url": body.manifest_url, "created": len(created), "skipped": skipped},
     )
     return IngestResponse(
         corpus_id=corpus_id,
         manuscript_id=ms.id,
         pages_created=len(created),
+        pages_skipped=skipped,
         page_ids=[p.id for p in created],
     )
 
@@ -316,24 +358,32 @@ async def ingest_iiif_images(
     ms = await _get_or_create_manuscript(db, corpus_id)
     seq = await _next_sequence(db, ms.id)
 
+    dupes = _find_duplicate_labels(body.folio_labels)
+
     created: list[PageModel] = []
+    skipped = 0
     for i, (url, folio_label) in enumerate(zip(body.urls, body.folio_labels)):
+        page_id = _make_page_id(corpus.slug, folio_label, seq + i, dupes)
         page = await _create_page(
-            db, ms.id, corpus.slug, folio_label, seq + i,
+            db, ms.id, page_id, folio_label, seq + i,
             image_master_path=url,
         )
-        created.append(page)
+        if page is None:
+            skipped += 1
+        else:
+            created.append(page)
 
     ms.total_pages = (ms.total_pages or 0) + len(created)
     await db.commit()
 
     logger.info(
         "Images IIIF ingérées",
-        extra={"corpus_id": corpus_id, "count": len(created)},
+        extra={"corpus_id": corpus_id, "created": len(created), "skipped": skipped},
     )
     return IngestResponse(
         corpus_id=corpus_id,
         manuscript_id=ms.id,
         pages_created=len(created),
+        pages_skipped=skipped,
         page_ids=[p.id for p in created],
     )

backend/app/services/ai/model_registry.py

@@ -54,8 +54,9 @@ def get_available_providers() -> list[dict]:
                 model_count = len(models)
             except Exception as exc:
                 logger.warning(
-                    "Provider inaccessible lors de get_available_providers",
-                    extra={"provider": provider.provider_type, "error": str(exc)},
+                    "Provider %s inaccessible : %s",
+                    provider.provider_type.value,
+                    exc,
                 )
                 available = False
 
@@ -117,8 +118,9 @@ def list_all_models() -> list[ModelInfo]:
             )
         except Exception as exc:
             logger.warning(
-                "Provider inaccessible",
-                extra={"provider": provider.provider_type, "error": str(exc)},
+                "Provider %s inaccessible : %s",
+                provider.provider_type.value,
+                exc,
             )
 
     return result

backend/app/services/ai/provider_mistral.py

@@ -67,7 +67,13 @@ class MistralProvider(AIProvider):
         if not self.is_configured():
             raise RuntimeError(f"Variable d'environnement manquante : {_ENV_KEY}")
 
-        from mistralai import Mistral  # import local — dépendance optionnelle
+        try:
+            from mistralai import Mistral  # v1.x — import local
+        except ImportError as exc:
+            raise ImportError(
+                "Impossible d'importer 'Mistral' depuis mistralai. "
+                "Vérifiez que le package est installé : pip install 'mistralai>=1.0'"
+            ) from exc
 
         api_key = os.environ[_ENV_KEY]
         client = Mistral(api_key=api_key)

backend/tests/test_api_ingest.py

@@ -417,3 +417,103 @@ async def test_ingest_images_corpus_id_in_response(async_client, db_session):
         json={"urls": ["https://x.com/1.jpg"], "folio_labels": ["f001r"]},
     )).json()
     assert data["corpus_id"] == corpus.id
+
+
+# ---------------------------------------------------------------------------
+# Réingestion — pas de 500
+# ---------------------------------------------------------------------------
+
+@pytest.mark.asyncio
+async def test_reingest_manifest_skips_existing_pages(async_client, db_session, monkeypatch):
+    """Réingérer le même manifest ne provoque pas de 500 (UNIQUE constraint).
+
+    La deuxième ingestion doit retourner 201 avec pages_created=0 et pages_skipped=N.
+    """
+    corpus = await _make_corpus(db_session, slug="reingest")
+    manifest = _iiif3_manifest(n_canvases=2)
+
+    async def fake_fetch(url: str) -> dict:
+        return manifest
+
+    monkeypatch.setattr(ingest_module, "_fetch_json_manifest", fake_fetch)
+
+    # Première ingestion
+    resp1 = await async_client.post(
+        f"/api/v1/corpora/{corpus.id}/ingest/iiif-manifest",
+        json={"manifest_url": "https://example.com/manifest"},
+    )
+    assert resp1.status_code == 201
+    data1 = resp1.json()
+    assert data1["pages_created"] == 2
+    assert data1["pages_skipped"] == 0
+
+    # Deuxième ingestion — même manifest
+    resp2 = await async_client.post(
+        f"/api/v1/corpora/{corpus.id}/ingest/iiif-manifest",
+        json={"manifest_url": "https://example.com/manifest"},
+    )
+    assert resp2.status_code == 201
+    data2 = resp2.json()
+    assert data2["pages_created"] == 0
+    assert data2["pages_skipped"] == 2
+
+
+@pytest.mark.asyncio
+async def test_reingest_images_skips_existing_pages(async_client, db_session):
+    """Réingérer les mêmes images ne provoque pas de 500."""
+    corpus = await _make_corpus(db_session, slug="reingest2")
+
+    payload = {"urls": ["https://x.com/a.jpg"], "folio_labels": ["f001r"]}
+
+    resp1 = await async_client.post(
+        f"/api/v1/corpora/{corpus.id}/ingest/iiif-images", json=payload,
+    )
+    assert resp1.status_code == 201
+    assert resp1.json()["pages_created"] == 1
+
+    resp2 = await async_client.post(
+        f"/api/v1/corpora/{corpus.id}/ingest/iiif-images", json=payload,
+    )
+    assert resp2.status_code == 201
+    assert resp2.json()["pages_created"] == 0
+    assert resp2.json()["pages_skipped"] == 1
+
+
+@pytest.mark.asyncio
+async def test_ingest_manifest_duplicate_labels_no_collision(async_client, db_session, monkeypatch):
+    """Deux canvases avec le même label ne provoquent pas de collision d'ID."""
+    corpus = await _make_corpus(db_session, slug="dupe-labels")
+    manifest = {
+        "@context": "http://iiif.io/api/presentation/3/context.json",
+        "type": "Manifest",
+        "label": {"fr": ["Test"]},
+        "items": [
+            {
+                "id": f"https://example.com/canvas/{i}",
+                "type": "Canvas",
+                "label": {"none": ["NP"]},
+                "items": [{
+                    "type": "AnnotationPage",
+                    "items": [{
+                        "type": "Annotation",
+                        "motivation": "painting",
+                        "body": {"id": f"https://example.com/img/{i}.jpg", "type": "Image"},
+                        "target": f"https://example.com/canvas/{i}",
+                    }],
+                }],
+            }
+            for i in range(1, 4)
+        ],
+    }
+
+    monkeypatch.setattr(ingest_module, "_fetch_json_manifest", AsyncMock(return_value=manifest))
+
+    resp = await async_client.post(
+        f"/api/v1/corpora/{corpus.id}/ingest/iiif-manifest",
+        json={"manifest_url": "https://example.com/manifest"},
+    )
+    assert resp.status_code == 201
+    data = resp.json()
+    assert data["pages_created"] == 3
+    # All IDs must be distinct
+    assert len(set(data["page_ids"])) == 3