feat(qualite): retenter automatiquement les traductions livrees dans la mauvaise ecriture

Le defaut le plus sournois du pipeline etait silencieux : de l'arabe
livre pour une cible persane (meme ecriture, mauvaise langue) passe
inapercu et part chez le lecteur. Desormais chaque lot traduit est
verifie par le detecteur d'ecritures, et chaque segment fautif est
redemande une fois au moteur avec une consigne renforcee (nom de la
langue + lettres specifiques, ex. persan پ چ ژ گ). La seconde tentative
ne remplace la premiere que si elle passe le meme controle.

- services/quality/script_detector.py : extraction d'un controle
  script_issue() reutilisable ; detect_arabic_variant signale des
 ormais un long texte en ecriture arabe sans aucune lettre specifique
  de la langue cible (arabe pur livre pour du persan/ourdou/pachto)
- translators/segments.py : retry_wrong_script() + construction de la
  consigne renforcee, sans jamais faire echouer le travail
- Word, Excel, PDF : branchement apres la memoire de traduction et les
  validations humaines ; le texte inchange (chiffres, noms propres) ne
  declenche jamais de retentative
- 14 tests nouveaux (tests/test_translators/test_script_retry.py)

tests/test_translators/test_script_retry.py

@@ -0,0 +1,212 @@
+"""
+Tests du garde-fou d'écriture (wrong-script retry).
+
+Scénario principal : un LLM livre de l'arabe alors que la cible est le
+persan — même écriture, mauvaise langue, indétectable à l'œil d'un
+non-lecteur. Le détecteur doit le signaler et le traducteur doit
+redemander une fois avec une consigne renforcée, sans jamais risquer
+de dégrader le document (la 2e tentative ne remplace que si elle passe
+le même contrôle).
+"""
+
+from docx import Document
+
+from services.providers.base import TranslationProvider
+from services.providers.schemas import TranslationRequest, TranslationResponse
+from services.quality.script_detector import script_issue
+from translators.segments import retry_wrong_script
+from translators.word_translator import WordTranslator
+
+# Arabe pur (aucune lettre persane spécifique), bien plus de 25 lettres.
+ARABIC_FOR_PERSIAN = "مرحبا بكم في صفحة المشاريع الجديدة الخاصة بنا"
+# Persan correct : contient پ et ژ (lettres spécifiques du persan).
+GOOD_PERSIAN = "به صفحه پروژه های جدید ما خوش آمدید"
+SOURCE_EN = "Welcome to our new projects page"
+
+
+class SequencedMockProvider(TranslationProvider):
+    """Renvoie une mauvaise traduction, puis la bonne dès que la requête
+    porte la consigne de retentative (détectée via le custom prompt)."""
+
+    def __init__(self, wrong: dict, corrected: dict):
+        self._wrong = wrong
+        self._corrected = corrected
+        self.calls = []  # (texte, porte_la_consigne_de_retry)
+
+    def get_name(self) -> str:
+        return "sequenced-mock"
+
+    def is_available(self) -> bool:
+        return True
+
+    def translate_text(self, request: TranslationRequest) -> TranslationResponse:
+        custom = (request.metadata or {}).get("custom_prompt") or ""
+        is_retry = "CRITICAL RETRY" in custom
+        self.calls.append((request.text, is_retry))
+        table = self._corrected if is_retry else self._wrong
+        return TranslationResponse(
+            translated_text=table.get(request.text, request.text),
+            provider_name="sequenced-mock",
+            source_language=request.source_language,
+        )
+
+    def translate_batch(self, requests: list) -> list:
+        return [self.translate_text(req) for req in requests]
+
+
+# ---------------------------------------------------------------------------
+# script_issue — détection seule
+# ---------------------------------------------------------------------------
+
+
+class TestScriptIssue:
+    def test_pure_arabic_for_persian_flagged(self):
+        reason = script_issue(ARABIC_FOR_PERSIAN, "fa")
+        assert reason is not None
+        assert "fa" in reason
+
+    def test_correct_persian_passes(self):
+        assert script_issue(GOOD_PERSIAN, "fa") is None
+
+    def test_latin_for_persian_flagged(self):
+        assert script_issue("Bienvenue sur notre page", "fa") is not None
+
+    def test_cyrillic_for_french_flagged(self):
+        reason = script_issue("Добро пожаловать на новую страницу", "fr")
+        assert reason is not None
+
+    def test_short_pure_arabic_stays_tolerated(self):
+        # Texte court : pas assez de signal pour distinguer arabe et
+        # persan sans lettre discriminante — comportement historique.
+        assert script_issue("السلام عليكم", "fa") is None
+
+    def test_identity_and_empty_are_never_flagged(self):
+        assert script_issue("", "fa") is None
+        assert script_issue("2024", "fa") is None
+
+
+# ---------------------------------------------------------------------------
+# retry_wrong_script — mécanisme seul
+# ---------------------------------------------------------------------------
+
+
+class TestRetryWrongScript:
+    def test_retry_replaces_with_valid_translation(self):
+        def translate_fn(texts, hint):
+            assert "CRITICAL RETRY" in hint
+            assert texts == [SOURCE_EN]
+            return [GOOD_PERSIAN]
+
+        result, fixed = retry_wrong_script(
+            [SOURCE_EN], [ARABIC_FOR_PERSIAN], "fa", translate_fn
+        )
+        assert fixed == 1
+        assert result[0] == GOOD_PERSIAN
+
+    def test_keeps_first_attempt_when_retry_still_wrong(self):
+        def translate_fn(texts, hint):
+            return [ARABIC_FOR_PERSIAN]  # la 2e tentative est tout aussi fausse
+
+        result, fixed = retry_wrong_script(
+            [SOURCE_EN], [ARABIC_FOR_PERSIAN], "fa", translate_fn
+        )
+        assert fixed == 0
+        assert result[0] == ARABIC_FOR_PERSIAN
+
+    def test_identity_output_never_triggers_retry(self):
+        def translate_fn(texts, hint):  # pragma: no cover — ne doit pas servir
+            raise AssertionError("no retry expected for identity output")
+
+        result, fixed = retry_wrong_script(
+            ["Microsoft 2024"], ["Microsoft 2024"], "fa", translate_fn
+        )
+        assert fixed == 0
+        assert result == ["Microsoft 2024"]
+
+    def test_correct_translation_never_triggers_retry(self):
+        def translate_fn(texts, hint):  # pragma: no cover
+            raise AssertionError("no retry expected for a correct translation")
+
+        result, fixed = retry_wrong_script(
+            [SOURCE_EN], [GOOD_PERSIAN], "fa", translate_fn
+        )
+        assert fixed == 0
+        assert result == [GOOD_PERSIAN]
+
+    def test_provider_error_keeps_originals(self):
+        def translate_fn(texts, hint):
+            raise RuntimeError("boom")
+
+        result, fixed = retry_wrong_script(
+            [SOURCE_EN], [ARABIC_FOR_PERSIAN], "fa", translate_fn
+        )
+        assert fixed == 0
+        assert result == [ARABIC_FOR_PERSIAN]
+
+    def test_only_offenders_are_resent(self):
+        sent = []
+
+        def translate_fn(texts, hint):
+            sent.extend(texts)
+            return [GOOD_PERSIAN] * len(texts)
+
+        sources = [SOURCE_EN, "Second text", "Third text"]
+        translations = [ARABIC_FOR_PERSIAN, "متنی که کاملاً درست است", "سلام دوست من"]
+        # La 2e contient ک ? non — vérifions plutôt avec un persan valide
+        # pour montrer que seules les traductions fautives repartent.
+        translations[1] = "این متن کاملاً درست است"
+        translations[2] = "این هم درست است"
+
+        result, fixed = retry_wrong_script(sources, translations, "fa", translate_fn)
+        assert sent == [SOURCE_EN]
+        assert fixed == 1
+
+
+# ---------------------------------------------------------------------------
+# Intégration — le traducteur Word corrige un lot entier
+# ---------------------------------------------------------------------------
+
+
+class TestWordIntegration:
+    def test_word_retries_arabic_delivered_for_persian(self, tmp_path):
+        provider = SequencedMockProvider(
+            {SOURCE_EN: ARABIC_FOR_PERSIAN},
+            {SOURCE_EN: GOOD_PERSIAN},
+        )
+        translator = WordTranslator(provider=provider)
+
+        doc = Document()
+        doc.add_paragraph(SOURCE_EN)
+        input_file = tmp_path / "input.docx"
+        doc.save(input_file)
+
+        output_file = tmp_path / "output.docx"
+        translator.translate_file(input_file, output_file, "fa")
+
+        # Une demande initiale + une retentative avec consigne renforcée
+        non_retry = [c for c in provider.calls if not c[1]]
+        retry = [c for c in provider.calls if c[1]]
+        assert len(non_retry) == 1
+        assert len(retry) == 1
+        assert retry[0][0] == SOURCE_EN
+
+        doc_out = Document(output_file)
+        assert GOOD_PERSIAN in doc_out.paragraphs[0].text
+
+    def test_word_no_retry_for_latin_target(self, tmp_path):
+        provider = SequencedMockProvider(
+            {SOURCE_EN: "Bienvenue sur notre page"}, {}
+        )
+        translator = WordTranslator(provider=provider)
+
+        doc = Document()
+        doc.add_paragraph(SOURCE_EN)
+        input_file = tmp_path / "input.docx"
+        doc.save(input_file)
+
+        output_file = tmp_path / "output.docx"
+        translator.translate_file(input_file, output_file, "fr")
+
+        # Traduction latine correcte pour une cible latine : une seule demande
+        assert len(provider.calls) == 1
+        assert not provider.calls[0][1]