Traduire son contenu automatiquement avec l'IA

import json

def detect_language(text, client):
    """Detects the language of a text via LLM"""
    response = client.chat.completions.create(
        model="google/gemini-2.0-flash-001",
        messages=[{
            "role": "user",
            "content": f"""Detect the language of this text.
Reply ONLY with JSON: {{"lang": "iso_code", "confidence": 0.0-1.0}}

Text: {text[:500]}"""
        }],
        temperature=0
    )
    return json.loads(response.choices[0].message.content)

# Example
result = detect_language("Bonjour, ceci est un test.")
# → {"lang": "fr", "confidence": 0.99}

import re

def prepare_content(markdown_text):
    """Protects elements that should not be translated"""
    protected = {}
    counter = 0

    # Protect code blocks
    def protect_code(match):
        nonlocal counter
        key = f"__CODE_BLOCK_{counter}__"
        protected[key] = match.group(0)
        counter += 1
        return key

    text = re.sub(r'```[\s\S]*?```', protect_code, markdown_text)

    # Protect URLs
    def protect_url(match):
        nonlocal counter
        key = f"__URL_{counter}__"
        protected[key] = match.group(0)
        counter += 1
        return key

    text = re.sub(r'https?://[^\s\)]+', protect_url, text)

    # Protect internal links /out?id=X
    text = re.sub(r'(/out\?id=\d+)',
                  lambda m: protect_url(m), text)

    return text, protected

def restore_content(translated_text, protected):
    """Restores protected elements after translation"""
    for key, value in protected.items():
        translated_text = translated_text.replace(key, value)
    return translated_text

def translate_content(text, source_lang, target_lang, client, context=""):
    """Translates content while preserving tone and SEO"""

    system_prompt = f"""You are a professional translator specializing
in tech/AI content. You translate from {source_lang} to {target_lang}.

STRICT RULES:
1. Preserve EXACTLY the markdown formatting (headings, lists, bold, italic, tables)
2. Do NOT translate elements between __CODE_BLOCK_X__ or __URL_X__
3. Adapt idiomatic expressions naturally
4. Preserve the tone: if it's casual, stay casual
5. Common English technical terms stay in English:
   API, LLM, token, prompt, pipeline, markdown, SEO, etc.
6. Optimize for SEO in the target language:
   - Use natural keywords
   - Keep sentences readable (no word-for-word translation)
7. NEVER add or remove content
8. Emojis remain identical"""

    user_prompt = f"""Translate this content from {source_lang} to {target_lang}.
{"Context: " + context if context else ""}

---
{text}
---

Translation:"""

    response = client.chat.completions.create(
        model="anthropic/claude-sonnet-4",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_prompt}
        ],
        temperature=0.3,
        max_tokens=8000
    )

    return response.choices[0].message.content

def review_translation(original, translated, source_lang, target_lang, client):
    """Automatic translation quality review"""

    prompt = f"""Compare this translation and rate it.

ORIGINAL ({source_lang}):
{original[:3000]}

TRANSLATION ({target_lang}):
{translated[:3000]}

Evaluate on these criteria (score /10 each):
1. Fidelity to original meaning
2. Fluency in target language
3. Formatting preservation
4. Cultural adaptation
5. SEO quality

Reply in JSON:
{{
  "scores": {{"fidelity": X, "fluency": X, "formatting": X, "culture": X, "seo": X}},
  "overall_score": X,
  "issues": ["list of detected problems"],
  "suggestions": ["suggested improvements"],
  "approved": true/false
}}

Approve (true) if overall_score >= 7.5"""

    response = client.chat.completions.create(
        model="google/gemini-2.0-flash-001",
        messages=[{"role": "user", "content": prompt}],
        temperature=0
    )

    return json.loads(response.choices[0].message.content)

def translation_pipeline(content, target_lang="en", client=None):
    """Complete automatic translation pipeline"""

    # 1. Language detection
    lang_info = detect_language(content, client)
    source_lang = lang_info["lang"]
    print(f"📝 Language detected: {source_lang} ({lang_info['confidence']*100:.0f}%)")

    if source_lang == target_lang:
        print("⚠️ Same source and target language!")
        return content

    # 2. Preparation
    prepared, protected = prepare_content(content)
    print(f"🔒 {len(protected)} elements protected")

    # 3. Translation
    print(f"🔄 Translating {source_lang} → {target_lang}...")
    translated = translate_content(prepared, source_lang, target_lang, client)

    # 4. Restoration
    final = restore_content(translated, protected)

    # 5. Quality review
    print("🔍 Quality review...")
    review = review_translation(content, final, source_lang, target_lang, client)

    print(f"📊 Overall score: {review['overall_score']}/10")

    if not review["approved"]:
        print("⚠️ Translation rejected, retrying...")
        # Relaunch with suggestions
        context = "Corrections to apply: " + ", ".join(review["suggestions"])
        prepared, protected = prepare_content(content)
        translated = translate_content(prepared, source_lang, target_lang, client, context)
        final = restore_content(translated, protected)

    return final, review

"Tu vas voir, c'est super simple !"
→ ✅ "You'll see, it's super easy!"
→ ❌ "You will observe, it is remarkably simple."

"Cette implémentation nécessite une configuration préalable."
→ ✅ "This implementation requires prior configuration."
→ ❌ "You gotta set things up before using this."

Before translating, identify the 5 main SEO keywords
in the source text. Find their most searched equivalents
in the target language (using your knowledge). Use these
equivalents naturally in the translation.

# ❌ Common errors after translation

## 🚀 Title without space    → the LLM removes the space after the emoji
**bold text**badly closed → the LLM forgets the **
[link](url "title")       → the LLM translates the URL
| table | broken          → the LLM changes alignment

# ✅ Solutions

1. Explicitly request preservation in the system prompt
2. Validate markdown after translation with a parser
3. Compare structure (number of #, **, [], |) before/after

import re

def validate_markdown_structure(original, translated):
    """Checks that the markdown structure is preserved"""
    checks = {
        "headings": (r'^#{1,6}\s', re.MULTILINE),
        "bold": (r'\*\*', 0),
        "links": (r'\[.*?\]\(.*?\)', 0),
        "code_blocks": (r'```', 0),
        "tables": (r'\|', 0),
        "lists": (r'^\s*[-*]\s', re.MULTILINE),
    }

    issues = []
    for name, (pattern, flags) in checks.items():
        orig_count = len(re.findall(pattern, original, flags))
        trans_count = len(re.findall(pattern, translated, flags))
        if orig_count != trans_count:
            issues.append(f"{name}: {orig_count} → {trans_count}")

    return issues

# Via OpenRouter (OpenAI-compatible)
from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="sk-or-..."  # Your OpenRouter key
)

response = client.chat.completions.create(
    model="google/gemini-2.0-flash-001",
    messages=[{
        "role": "user",
        "content": "Translate to English while preserving markdown:\n\n## 🚀 Mon titre\nVoici du **texte en gras** et un [lien](/out?id=1)."
    }]
)

print(response.choices[0].message.content)
# → ## 🚀 My Title
# → Here is some **bold text** and a [link](/out?id=1).

# Installation with Ollama
curl -fsSL https://ollama.ai/install.sh | sh
ollama pull llama3.3:70b

# Translation test
ollama run llama3.3:70b "Translate to English, preserve markdown formatting:

## 🔧 Configuration
Voici comment **configurer** votre système.
1. Installez les dépendances
2. Lancez le serveur
"

# Conceptual configuration example
translation_pipeline:
  trigger: "new_article_published"
  steps:
    - detect_language
    - prepare_content
    - translate (model: gemini-flash)
    - review_quality (model: claude-sonnet)
    - validate_markdown
    - save_translation
  notify: telegram

## 🚀 Pourquoi automatiser sa vie numérique ?

On passe en moyenne **3h par jour** sur des tâches répétitives.
Envoyer des emails, poster sur les réseaux, vérifier ses stats...

Avec l'IA, tu peux **récupérer ce temps** et te concentrer
sur ce qui compte vraiment.

> "L'automatisation n'est pas de la paresse, c'est de l'intelligence."

### Les outils indispensables

| Outil | Usage | Prix |
|-------|-------|------|
| OpenClaw | Agent IA personnel | Gratuit |
| Zapier | Connexion d'apps | Freemium |

## 🚀 Why Automate Your Digital Life?

We spend an average of **3 hours a day** on repetitive tasks.
Sending emails, posting on social media, checking stats...

With AI, you can **reclaim that time** and focus
on what truly matters.

> "Automation isn't laziness, it's intelligence."

### Essential Tools

| Tool | Use Case | Price |
|------|----------|-------|
| OpenClaw | Personal AI agent | Free |
| Zapier | App integration | Freemium |

TARGET_LANGUAGES = {
    "en": "English",
    "es": "Spanish",
    "de": "German",
    "pt": "Portuguese",
    "it": "Italian",
}

async def translate_all(content, source_lang="fr"):
    """Translates an article into all target languages"""
    import asyncio

    tasks = []
    for lang_code, lang_name in TARGET_LANGUAGES.items():
        if lang_code != source_lang:
            tasks.append(translate_single(content, source_lang, lang_code))

    results = await asyncio.gather(*tasks)
    return dict(zip(TARGET_LANGUAGES.keys(), results))