Sono lieto di annunciare il rilascio della versione 1.5 del mio script Traduttore Markdown Potenziato da AI. Questo aggiornamento introduce diverse migliorie significative, in particolare l’aggiornamento dei modelli predefiniti, l’ottimizzazione dei prompt di traduzione, una rifattorizzazione del codice e una migliore gestione dei file di output.
Novità della Versione 1.5
Aggiornamento dei Modelli e delle Chiavi API Predefinite
In questa versione ho aggiornato i modelli e le chiavi API predefinite per utilizzare le ultime versioni disponibili dei modelli di IA :
- OpenAI : Aggiornamento a
gpt-4o. - Mistral AI : Passaggio a
mistral-large-latest. - Claude di Anthropic : Aggiornamento a
claude-3-5-sonnet-20240620e aggiunta diDEFAULT_ANTHROPIC_API_KEY.
Questi aggiornamenti garantiscono che lo script utilizzi i modelli più recenti e performanti per la traduzione, offrendo così traduzioni di qualità superiore.
Ottimizzazione dei Prompt di Traduzione
Ho arricchito i prompt utilizzati per interagire con i modelli di IA al fine di migliorare la chiarezza e l’efficacia delle traduzioni :
- Istruzioni Dettagliate : I prompt includono ora direttive specifiche per preservare i metadati, le URL, i percorsi delle immagini, i blocchi di codice e gli elementi di formattazione come il ‘front matter’ nei file Markdown.
- Preservazione della Formattazione : Insistendo sulla non-traduzione degli elementi di formattazione e del codice, le traduzioni prodotte rispettano meglio la struttura originale dei documenti.
Rifattorizzazione e Miglioramenti del Codice
Sono stati apportati aggiustamenti per migliorare la manutenibilità e le prestazioni dello script :
- Sostituzione di
MistralClientconMistral: Ho aggiornato l’inizializzazione del client per Mistral AI utilizzando la classeMistralper una migliore compatibilità con le nuove versioni dell’API. - Riorganizzazione degli Imports : Gli import sono stati riorganizzati per migliorare la leggibilità e facilitare la manutenzione del codice.
- Miglioramento della Segmentazione dei Testi : La funzione di segmentazione gestisce ora meglio i testi lunghi mantenendo i punti di interruzione naturali, il che migliora la coerenza e la fluidità delle traduzioni.
- Gestione dei Blocchi di Codice : Lo script preserva ora i blocchi di codice durante la traduzione per mantenere il formato originale e evitare potenziali errori nel codice.
Gestione Migliorata dei File di Output
- Denominazione dei File : Ho invertito l’ordine del modello e della lingua nei nomi dei file di output per facilitare l’organizzazione e la ricerca delle traduzioni. Per esempio :
mon_article-en-gpt-4o.md. - Verifica delle Traduzioni Esistenti : Lo script verifica ora se esiste già una traduzione per un dato file, indipendentemente dal modello utilizzato, per evitare duplicazioni inutili. L’opzione
--forcepuò essere usata per forzare la traduzione se necessario.
Altre Miglioramenti
- Pulizia del Codice : Rimozione delle righe vuote non necessarie e aggiustamenti minori per migliorare la struttura e la leggibilità dello script.
- Maggiore Flessibilità : Lo script è progettato per essere facilmente estendibile, consentendo l’aggiunta futura di nuove funzionalità o il supporto di nuovi modelli di IA come quelli di Anthropic e di Mistral AI.
Codice Aggiornato
Ecco il nuovo script :
#!/usr/bin/env python3
import os
import argparse
import time
import re
import glob
from openai import OpenAI
import anthropic
from mistralai import Mistral
EXCLUDE_PATTERNS = ["traductions_"]
# Initialisation de la configuration avec les valeurs par défaut
DEFAULT_OPENAI_API_KEY = "votre-cle-api-openai-par-defaut"
DEFAULT_MISTRAL_API_KEY = "votre-cle-api-mistral-par-defaut"
DEFAULT_ANTHROPIC_API_KEY = "votre-cle-api-anthropic-par-defaut"
DEFAULT_MODEL_OPENAI = "gpt-4o"
DEFAULT_MODEL_MISTRAL = "mistral-large-latest"
DEFAULT_MODEL_CLAUDE = "claude-3-5-sonnet-20240620"
DEFAULT_SOURCE_LANG = "fr"
DEFAULT_TARGET_LANG = "en"
DEFAULT_SOURCE_DIR = "content/posts"
DEFAULT_TARGET_DIR = "traductions_en"
MODEL_TOKEN_LIMITS = {
"gpt-4o": 4096,
"gpt-4": 8192,
"gpt-4-32k": 32768,
"gpt-4-0613": 8192,
"gpt-4-32k-0613": 32768,
"mistral-large-latest": 4096,
"claude-3-5-sonnet-20240620": 8192,
}
def segment_text(text, max_length):
"""
Divise un texte Markdown en segments ne dépassant pas la longueur maximale spécifiée,
en essayant de conserver des points de coupure naturels.
Args:
text (str): Texte Markdown à diviser.
max_length (int): Longueur maximale de chaque segment.
Returns:
list[str]: Liste des segments de texte Markdown.
"""
segments = []
while text:
if len(text) <= max_length:
segments.append(text)
break
segment = text[:max_length]
next_index = max_length
# Recherche de points de coupure naturels (fin de phrase, fin de paragraphe, fin de titre)
last_good_break = max(
segment.rfind(". "), segment.rfind("\n\n"), segment.rfind("\n#")
)
if last_good_break != -1:
next_index = last_good_break + 1
segments.append(text[:next_index])
text = text[next_index:]
return segments
def translate(
text, client, args, use_mistral=False, use_claude=False, is_translation_note=False
):
"""
Traduit un texte à l'aide de l'API OpenAI, Mistral AI ou Claude, selon les paramètres spécifiés.
Cette fonction segmente d'abord le texte pour s'assurer qu'il respecte la limite de tokens du modèle.
Elle utilise un argument optionnel 'is_translation_note' pour gérer différemment les notes de traduction.
Args:
text (str): Texte à traduire.
client: Objet client de l'API de traduction (OpenAI, Mistral AI ou Claude).
args: Objet argparse contenant les arguments de la ligne de commande.
use_mistral (bool): Si True, utilise l'API Mistral AI pour la traduction.
use_claude (bool): Si True, utilise l'API Claude pour la traduction.
is_translation_note (bool): Si True, le texte est une note de traduction.
Returns:
str: Texte traduit.
"""
model_limit = MODEL_TOKEN_LIMITS.get(args.model, 4096)
segments = segment_text(text, model_limit)
translated_segments = []
for segment in segments:
try:
prompt_message = ""
if is_translation_note:
prompt_message = (
f"Directly translate to {args.target_lang} without any additions, ensuring that elements such as URLs, image paths, code blocks, "
"and specifically 'front matter' metadata (like 'title', 'date', 'categories', 'tags', 'draft') are not translated. "
"The 'front matter' is a block of metadata used at the beginning of some file formats like Markdown for static site generators "
"such as Hugo. These metadata should remain unchanged. Additionally, any specific file formatting or markup language elements "
"(e.g., special tags, preprocessing directives) should also be left unchanged. Here is the text to translate: "
f"'{segment}'."
)
else:
prompt_message = (
f"Perform a direct translation from {args.source_lang} to {args.target_lang}, without altering URLs. "
f"Begin the translation immediately without any introduction or added notes, and ensure not to include any additional "
f"information or context beyond the requested translation: '{segment}'. Strictly follow the source text without adding, "
f"modifying, or omitting elements that are not explicitly present."
)
if use_mistral:
messages = [{"role": "user", "content": prompt_message}]
response = client.chat.complete(model=args.model, messages=messages)
translated_text = response.choices[0].message.content.strip()
elif use_claude:
messages = [{"role": "user", "content": prompt_message}]
response = client.messages.create(
model=args.model, max_tokens=4096, messages=messages
)
# Extraire le texte de chaque ContentBlock dans la liste de réponses
translated_texts = [
block.text.strip() for block in response.content
] # Assurez-vous que .content est la liste des ContentBlock
translated_text = " ".join(translated_texts)
else:
messages = [
{"role": "system", "content": prompt_message},
{"role": "user", "content": segment},
]
response = client.chat.completions.create(
model=args.model, messages=messages
)
translated_text = response.choices[0].message.content.strip()
except Exception as e:
raise RuntimeError(f"Erreur lors de la traduction : {e}")
translated_segments.append(translated_text)
return " ".join(translated_segments)
def translate_markdown_file(
file_path,
output_path,
client,
args,
use_mistral,
use_claude,
add_translation_note=False,
force=False,
):
"""
Traduit un fichier Markdown en utilisant les modèles de traitement du langage naturel de OpenAI, Mistral AI ou Claude.
Args:
file_path (str): Chemin complet vers le fichier d'entrée.
output_path (str): Chemin complet vers le fichier de sortie.
client: Objet client de traduction.
args: Arguments supplémentaires pour la traduction.
use_mistral (bool): Indique si l'API Mistral AI doit être utilisée pour la traduction.
use_claude (bool): Indique si l'API Claude doit être utilisée pour la traduction.
add_translation_note (bool): Indique si une note de traduction doit être ajoutée.
force (bool): Indique si la traduction doit être forcée même si une traduction existe déjà.
Returns:
None. Le résultat de la traduction est écrit dans le fichier de sortie spécifié.
En cas d'échec, un message est imprimé pour indiquer une erreur et suggérer de relancer le traitement.
"""
try:
# Calcul des chemins relatifs pour un affichage plus lisible
relative_file_path = os.path.join(
args.source_dir, os.path.relpath(file_path, start=args.source_dir)
)
relative_output_path = os.path.join(
args.target_dir, os.path.relpath(output_path, start=args.target_dir)
)
print(f"Traitement du fichier : {relative_file_path}")
start_time = time.time()
# Lecture du contenu du fichier
with open(file_path, "r", encoding="utf-8") as f:
content = f.read()
if not content:
print(
f"Le fichier '{relative_file_path}' est vide, aucune traduction n'est effectuée."
)
return
# Extraction et remplacement des blocs de code pour les préserver pendant la traduction
regex = re.compile(
r"(?P<start>^```(?P<block_language>(\w|-)+)\n)(?P<code>.*?\n)(?P<end>```)",
re.DOTALL | re.MULTILINE,
)
code_blocks = [match.group("code") for match in regex.finditer(content)]
placeholders = [f"#CODEBLOCK{index}#" for index, _ in enumerate(code_blocks)]
for placeholder, code_block in zip(placeholders, code_blocks):
content = content.replace(code_block, placeholder)
# Traduction du contenu
translated_content = translate(content, client, args, use_mistral, use_claude)
# Restauration des blocs de code dans le contenu traduit
for placeholder, code_block in zip(placeholders, code_blocks):
translated_content = translated_content.replace(placeholder, code_block)
# Ajout de la note de traduction si nécessaire
if add_translation_note:
translation_note = translate(
"Ce document a été traduit de la version "
+ args.source_lang
+ " vers la langue "
+ args.target_lang
+ " en utilisant le modèle "
+ args.model
+ ". Pour plus d'informations sur le processus de traduction, consultez https://gitlab.com/jls42/ai-powered-markdown-translator",
client,
args,
use_mistral,
use_claude,
True,
)
translated_content += "\n\n**" + translation_note + "**\n\n"
# Écriture du contenu traduit dans le fichier de sortie
clean_output_path = os.path.normpath(output_path)
if os.path.exists(clean_output_path) and not force:
print(
f"Le fichier '{relative_output_path}' existe déjà, aucune traduction n'est effectuée."
)
return
with open(clean_output_path, "w", encoding="utf-8") as f:
f.write(translated_content)
end_time = time.time()
print(
f"Fichier '{relative_file_path}' traduit en {end_time - start_time:.2f} secondes et enregistré sous : {relative_output_path}"
)
except IOError as e:
print(f"Erreur lors du traitement du fichier '{relative_file_path}': {e}")
except Exception as e:
print(
f"Une erreur inattendue est survenue lors de la traduction du fichier '{relative_file_path}': {e}\n"
"Veuillez relancer le traitement pour ce fichier."
)
def is_excluded(path):
"""
Vérifie si le chemin donné correspond à l'un des motifs d'exclusion.
Cette fonction parcourt la liste des motifs d'exclusion définis dans EXCLUDE_PATTERNS.
Si l'un de ces motifs est trouvé dans le chemin fourni, la fonction renvoie True,
indiquant que le chemin doit être exclu du processus de traduction.
Args:
path (str): Le chemin du fichier ou du répertoire à vérifier.
Returns:
bool: True si le chemin correspond à l'un des motifs d'exclusion, False sinon.
"""
for pattern in EXCLUDE_PATTERNS:
if pattern in path:
return True
return False
def translate_directory(
input_dir,
output_dir,
client,
args,
use_mistral,
use_claude,
add_translation_note,
force,
):
"""
Traduit tous les fichiers markdown dans le répertoire d'entrée et ses sous-répertoires.
``` ## Accesso al Codice Sorgente
Il codice sorgente completo, comprensivo di tutte le nuove funzionalità, è disponibile su GitLab. Non esitate a consultarlo, a utilizzarlo per i vostri progetti o a contribuire. Il vostro feedback è prezioso per migliorare continuamente questo strumento.
👉 [AI-Powered Markdown Translator su GitLab](https://gitlab.com/jls42/ai-powered-markdown-translator)
## Conclusione
Questo aggiornamento alla versione 1.5 segna un passo importante nell'evoluzione del mio script di traduzione automatica **AI-Powered Markdown Translator**. Aggiornando i modelli predefiniti e ottimizzando il codice, intendo offrire uno strumento ancora più potente e flessibile per rispondere alle vostre esigenze di traduzione. Spero che questi miglioramenti vi saranno utili e sono aperto ai vostri commenti e suggerimenti.
**Questo documento è stato tradotto dalla versione fr alla lingua it utilizzando il modello gpt-5-mini. Per maggiori informazioni sul processo di traduzione, consultate https://gitlab.com/jls42/ai-powered-markdown-translator**