861 lines
No EOL
30 KiB
Python
Executable file
861 lines
No EOL
30 KiB
Python
Executable file
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
"""
|
|
Script pour générer une page web interactive de correction des erreurs orthographiques et grammaticales.
|
|
Ce script:
|
|
1. Lit le rapport d'erreurs et le fichier CSV des erreurs
|
|
2. Génère une page HTML interactive dans le dossier build
|
|
3. Permet de corriger les erreurs directement dans le fichier livre.org
|
|
4. Permet d'ajouter des mots au dictionnaire personnalisé
|
|
5. Permet de marquer des erreurs comme "à ne pas traiter"
|
|
"""
|
|
|
|
import os
|
|
import re
|
|
import json
|
|
import csv
|
|
import shutil
|
|
from datetime import datetime
|
|
|
|
# Créer le dossier build s'il n'existe pas
|
|
if not os.path.exists('build'):
|
|
os.makedirs('build')
|
|
|
|
# Créer le dossier pour les ressources statiques s'il n'existe pas
|
|
STATIC_DIR = os.path.join('build', 'static')
|
|
if not os.path.exists(STATIC_DIR):
|
|
os.makedirs(STATIC_DIR)
|
|
|
|
# Créer les sous-dossiers pour CSS et JS
|
|
CSS_DIR = os.path.join(STATIC_DIR, 'css')
|
|
JS_DIR = os.path.join(STATIC_DIR, 'js')
|
|
|
|
for directory in [CSS_DIR, JS_DIR]:
|
|
if not os.path.exists(directory):
|
|
os.makedirs(directory)
|
|
|
|
def parse_error_report(report_path):
|
|
"""
|
|
Parse le rapport d'erreurs pour extraire les informations sur les erreurs.
|
|
"""
|
|
with open(report_path, 'r', encoding='utf-8') as file:
|
|
content = file.read()
|
|
|
|
# Extraire les sections par chapitre
|
|
chapter_pattern = r'## Chapitre: (.*?)\n\n(.*?)(?=\n---|\Z)'
|
|
chapters = re.findall(chapter_pattern, content, re.DOTALL)
|
|
|
|
errors_by_chapter = {}
|
|
|
|
for chapter_title, chapter_content in chapters:
|
|
# Extraire les erreurs d'orthographe
|
|
spelling_pattern = r'### Erreurs d\'orthographe\n\n(.*?)(?=\n\n### Erreurs grammaticales|\Z)'
|
|
spelling_match = re.search(spelling_pattern, chapter_content, re.DOTALL)
|
|
|
|
spelling_errors = []
|
|
if spelling_match and "Aucune erreur d'orthographe détectée" not in spelling_match.group(1):
|
|
spelling_text = spelling_match.group(1)
|
|
|
|
# Nouveau motif pour extraire les erreurs d'orthographe avec contexte étendu
|
|
word_pattern = r'- \*\*(.*?)\*\*: (.*?)(?=\n- \*\*|\Z)'
|
|
for word_match in re.finditer(word_pattern, spelling_text, re.DOTALL):
|
|
word = word_match.group(1)
|
|
suggestions_text = word_match.group(2).strip()
|
|
suggestions = []
|
|
if suggestions_text != "Aucune suggestion":
|
|
suggestions = [s.strip() for s in suggestions_text.split(',')]
|
|
|
|
# Extraire les occurrences pour ce mot
|
|
occurrence_text = word_match.group(0)
|
|
occurrence_pattern = r' - \*\*Occurrence (\d+)\*\*:\n - \*\*Contexte\*\*: (.*?)\n - \*\*Contexte étendu\*\*: ```\n(.*?)\n```'
|
|
|
|
occurrences = re.finditer(occurrence_pattern, occurrence_text, re.DOTALL)
|
|
|
|
# S'il y a des occurrences, les traiter
|
|
occurrences_found = False
|
|
for occ_match in occurrences:
|
|
occurrences_found = True
|
|
occ_num = occ_match.group(1)
|
|
context = occ_match.group(2).strip()
|
|
extended_context = occ_match.group(3).strip()
|
|
|
|
# Extraire le texte en gras du contexte (le mot mal orthographié)
|
|
error_text_match = re.search(r'\*\*(.*?)\*\*', context)
|
|
error_text = error_text_match.group(1) if error_text_match else word
|
|
|
|
# Nettoyer le contexte pour l'affichage
|
|
clean_context = re.sub(r'\*\*(.*?)\*\*', r'\1', context)
|
|
|
|
spelling_errors.append({
|
|
'word': word,
|
|
'context': clean_context,
|
|
'extended_context': extended_context,
|
|
'error_text': error_text,
|
|
'suggestions': suggestions,
|
|
'type': 'spelling'
|
|
})
|
|
|
|
# Si aucune occurrence n'a été trouvée, ajouter une entrée simple
|
|
if not occurrences_found:
|
|
spelling_errors.append({
|
|
'word': word,
|
|
'suggestions': suggestions,
|
|
'type': 'spelling'
|
|
})
|
|
|
|
# Extraire les erreurs grammaticales
|
|
grammar_pattern = r'### Erreurs grammaticales\n\n(.*?)(?=\n\n---|\Z)'
|
|
grammar_match = re.search(grammar_pattern, chapter_content, re.DOTALL)
|
|
|
|
grammar_errors = []
|
|
if grammar_match and "Aucune erreur grammaticale détectée" not in grammar_match.group(1):
|
|
grammar_text = grammar_match.group(1)
|
|
|
|
# Nouveau motif pour extraire les erreurs grammaticales avec contexte étendu
|
|
error_pattern = r'- \*\*Erreur (\d+)\*\*: (.*?)\n - \*\*Contexte\*\*: (.*?)(?:\n - \*\*Contexte étendu\*\*: ```\n(.*?)\n```)?(?:\n - \*\*Suggestions\*\*: (.*?))?(?=\n\n- \*\*Erreur|\Z)'
|
|
|
|
for error_match in re.finditer(error_pattern, grammar_text, re.DOTALL):
|
|
error_num = error_match.group(1)
|
|
message = error_match.group(2).strip()
|
|
context = error_match.group(3).strip()
|
|
extended_context = error_match.group(4).strip() if error_match.group(4) else None
|
|
suggestions_text = error_match.group(5).strip() if error_match.group(5) else "Aucune suggestion"
|
|
|
|
# Extraire le texte en gras du contexte (l'erreur elle-même)
|
|
error_text_match = re.search(r'\*\*(.*?)\*\*', context)
|
|
error_text = error_text_match.group(1) if error_text_match else ""
|
|
|
|
# Nettoyer le contexte pour l'affichage
|
|
clean_context = re.sub(r'\*\*(.*?)\*\*', r'\1', context)
|
|
|
|
suggestions = []
|
|
if suggestions_text != "Aucune suggestion":
|
|
suggestions = [s.strip() for s in suggestions_text.split(',')]
|
|
|
|
grammar_error = {
|
|
'message': message,
|
|
'context': clean_context,
|
|
'error_text': error_text,
|
|
'suggestions': suggestions,
|
|
'type': 'grammar'
|
|
}
|
|
|
|
# Ajouter le contexte étendu s'il existe
|
|
if extended_context:
|
|
grammar_error['extended_context'] = extended_context
|
|
|
|
grammar_errors.append(grammar_error)
|
|
|
|
errors_by_chapter[chapter_title] = {
|
|
'spelling': spelling_errors,
|
|
'grammar': grammar_errors
|
|
}
|
|
|
|
return errors_by_chapter
|
|
|
|
def create_css():
|
|
"""Crée le fichier CSS pour la page de corrections."""
|
|
css_content = """
|
|
body {
|
|
font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
|
|
margin: 0;
|
|
padding: 0;
|
|
background-color: #f5f5f5;
|
|
color: #333;
|
|
}
|
|
|
|
.container {
|
|
max-width: 1200px;
|
|
margin: 0 auto;
|
|
padding: 20px;
|
|
}
|
|
|
|
header {
|
|
background-color: #2c3e50;
|
|
color: white;
|
|
padding: 20px;
|
|
text-align: center;
|
|
margin-bottom: 30px;
|
|
}
|
|
|
|
h1, h2, h3, h4, h5 {
|
|
margin-top: 0;
|
|
}
|
|
|
|
.chapter-section {
|
|
background-color: white;
|
|
border-radius: 8px;
|
|
box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
|
|
padding: 20px;
|
|
margin-bottom: 30px;
|
|
}
|
|
|
|
.error-card {
|
|
border: 1px solid #ddd;
|
|
border-radius: 5px;
|
|
padding: 15px;
|
|
margin-bottom: 15px;
|
|
background-color: #fff;
|
|
}
|
|
|
|
.error-card.spelling {
|
|
border-left: 5px solid #3498db;
|
|
}
|
|
|
|
.error-card.grammar {
|
|
border-left: 5px solid #e74c3c;
|
|
}
|
|
|
|
.error-context {
|
|
background-color: #f9f9f9;
|
|
padding: 10px;
|
|
border-radius: 5px;
|
|
margin: 10px 0;
|
|
font-family: monospace;
|
|
white-space: pre-wrap;
|
|
line-height: 1.5;
|
|
}
|
|
|
|
.extended-context {
|
|
background-color: #f0f0f0;
|
|
padding: 10px;
|
|
border-radius: 5px;
|
|
margin: 10px 0;
|
|
border-left: 3px solid #7f8c8d;
|
|
}
|
|
|
|
.extended-context h5 {
|
|
margin-top: 0;
|
|
color: #7f8c8d;
|
|
font-size: 14px;
|
|
}
|
|
|
|
.extended-context pre {
|
|
margin: 0;
|
|
font-family: monospace;
|
|
white-space: pre-wrap;
|
|
line-height: 1.5;
|
|
font-size: 13px;
|
|
color: #555;
|
|
}
|
|
|
|
.error-word {
|
|
font-weight: bold;
|
|
color: #e74c3c;
|
|
text-decoration: underline;
|
|
text-decoration-style: wavy;
|
|
text-decoration-color: #e74c3c;
|
|
}
|
|
|
|
.suggestion-buttons {
|
|
display: flex;
|
|
flex-wrap: wrap;
|
|
gap: 10px;
|
|
margin-top: 10px;
|
|
}
|
|
|
|
.suggestion-btn {
|
|
background-color: #3498db;
|
|
color: white;
|
|
border: none;
|
|
border-radius: 4px;
|
|
padding: 5px 10px;
|
|
cursor: pointer;
|
|
font-size: 14px;
|
|
transition: background-color 0.3s;
|
|
}
|
|
|
|
.suggestion-btn:hover {
|
|
background-color: #2980b9;
|
|
}
|
|
|
|
.custom-correction {
|
|
margin-top: 15px;
|
|
padding: 10px;
|
|
background-color: #f9f9f9;
|
|
border-radius: 5px;
|
|
}
|
|
|
|
.custom-correction h5 {
|
|
margin-top: 0;
|
|
margin-bottom: 10px;
|
|
color: #555;
|
|
font-size: 14px;
|
|
}
|
|
|
|
.input-group {
|
|
display: flex;
|
|
gap: 10px;
|
|
}
|
|
|
|
.custom-input {
|
|
flex-grow: 1;
|
|
padding: 8px;
|
|
border: 1px solid #ddd;
|
|
border-radius: 4px;
|
|
font-size: 14px;
|
|
}
|
|
|
|
.custom-btn {
|
|
background-color: #9b59b6;
|
|
color: white;
|
|
border: none;
|
|
border-radius: 4px;
|
|
padding: 8px 15px;
|
|
cursor: pointer;
|
|
font-size: 14px;
|
|
transition: background-color 0.3s;
|
|
}
|
|
|
|
.custom-btn:hover {
|
|
background-color: #8e44ad;
|
|
}
|
|
|
|
.action-buttons {
|
|
display: flex;
|
|
gap: 10px;
|
|
margin-top: 15px;
|
|
}
|
|
|
|
.action-btn {
|
|
background-color: #2ecc71;
|
|
color: white;
|
|
border: none;
|
|
border-radius: 4px;
|
|
padding: 8px 15px;
|
|
cursor: pointer;
|
|
font-size: 14px;
|
|
transition: background-color 0.3s;
|
|
}
|
|
|
|
.action-btn.ignore {
|
|
background-color: #95a5a6;
|
|
}
|
|
|
|
.action-btn.dictionary {
|
|
background-color: #f39c12;
|
|
}
|
|
|
|
.action-btn:hover {
|
|
opacity: 0.9;
|
|
}
|
|
|
|
.success-message {
|
|
display: none;
|
|
background-color: #2ecc71;
|
|
color: white;
|
|
padding: 10px;
|
|
border-radius: 5px;
|
|
margin-top: 10px;
|
|
text-align: center;
|
|
}
|
|
|
|
.error-message {
|
|
display: none;
|
|
background-color: #e74c3c;
|
|
color: white;
|
|
padding: 10px;
|
|
border-radius: 5px;
|
|
margin-top: 10px;
|
|
text-align: center;
|
|
}
|
|
|
|
.tabs {
|
|
display: flex;
|
|
margin-bottom: 20px;
|
|
}
|
|
|
|
.tab {
|
|
padding: 10px 20px;
|
|
background-color: #ddd;
|
|
cursor: pointer;
|
|
border-radius: 5px 5px 0 0;
|
|
margin-right: 5px;
|
|
}
|
|
|
|
.tab.active {
|
|
background-color: white;
|
|
border-bottom: 2px solid #3498db;
|
|
}
|
|
|
|
.tab-content {
|
|
display: none;
|
|
}
|
|
|
|
.tab-content.active {
|
|
display: block;
|
|
}
|
|
"""
|
|
|
|
with open(os.path.join(CSS_DIR, 'corrections.css'), 'w', encoding='utf-8') as f:
|
|
f.write(css_content)
|
|
|
|
def create_js(errors_by_chapter):
|
|
"""Crée le fichier JavaScript pour la page de corrections."""
|
|
# Convertir les données en JSON pour les utiliser dans le JavaScript
|
|
errors_json = json.dumps(errors_by_chapter, ensure_ascii=False)
|
|
|
|
js_content = f"""
|
|
// Données des erreurs
|
|
const errorsByChapter = {errors_json};
|
|
|
|
// Fonction pour appliquer une correction
|
|
function applyCorrection(errorType, chapterTitle, errorIndex, correction) {{
|
|
// Préparer les données à envoyer
|
|
const data = {{
|
|
action: 'apply_correction',
|
|
error_type: errorType,
|
|
chapter: chapterTitle,
|
|
error_index: errorIndex,
|
|
correction: correction
|
|
}};
|
|
|
|
// Envoyer la requête au serveur
|
|
fetch('/api/corrections', {{
|
|
method: 'POST',
|
|
headers: {{
|
|
'Content-Type': 'application/json',
|
|
}},
|
|
body: JSON.stringify(data)
|
|
}})
|
|
.then(response => response.json())
|
|
.then(data => {{
|
|
if (data.success) {{
|
|
// Afficher un message de succès
|
|
const card = document.querySelector(`#${{errorType}}-${{chapterTitle.replace(/\\s+/g, '-')}}-${{errorIndex}}`);
|
|
const successMsg = card.querySelector('.success-message');
|
|
successMsg.textContent = 'Correction appliquée avec succès!';
|
|
successMsg.style.display = 'block';
|
|
|
|
// Masquer le message après 3 secondes
|
|
setTimeout(() => {{
|
|
successMsg.style.display = 'none';
|
|
}}, 3000);
|
|
|
|
// Désactiver les boutons de suggestion
|
|
const suggestionBtns = card.querySelectorAll('.suggestion-btn');
|
|
suggestionBtns.forEach(btn => {{
|
|
btn.disabled = true;
|
|
btn.style.opacity = '0.5';
|
|
}});
|
|
|
|
// Désactiver le champ de correction personnalisée
|
|
const customInput = card.querySelector('.custom-input');
|
|
const customBtn = card.querySelector('.custom-btn');
|
|
if (customInput) customInput.disabled = true;
|
|
if (customBtn) customBtn.disabled = true;
|
|
}} else {{
|
|
// Afficher un message d'erreur
|
|
const card = document.querySelector(`#${{errorType}}-${{chapterTitle.replace(/\\s+/g, '-')}}-${{errorIndex}}`);
|
|
const errorMsg = card.querySelector('.error-message');
|
|
errorMsg.textContent = data.message || 'Erreur lors de l\\'application de la correction.';
|
|
errorMsg.style.display = 'block';
|
|
|
|
// Masquer le message après 3 secondes
|
|
setTimeout(() => {{
|
|
errorMsg.style.display = 'none';
|
|
}}, 3000);
|
|
}}
|
|
}})
|
|
.catch(error => {{
|
|
console.error('Erreur:', error);
|
|
alert('Une erreur est survenue lors de la communication avec le serveur.');
|
|
}});
|
|
}}
|
|
|
|
// Fonction pour appliquer une correction personnalisée
|
|
function applyCustomCorrection(errorType, chapterTitle, errorIndex) {{
|
|
// Récupérer la valeur de la correction personnalisée
|
|
const inputId = `custom-${{errorType}}-${{chapterTitle.replace(/\\s+/g, '-')}}-${{errorIndex}}`;
|
|
const customInput = document.getElementById(inputId);
|
|
|
|
if (!customInput || !customInput.value.trim()) {{
|
|
alert('Veuillez entrer une correction.');
|
|
return;
|
|
}}
|
|
|
|
// Appliquer la correction
|
|
applyCorrection(errorType, chapterTitle, errorIndex, customInput.value.trim());
|
|
}}
|
|
|
|
// Ajouter des écouteurs d'événements pour les champs de saisie personnalisée
|
|
function setupCustomInputs() {{
|
|
const customInputs = document.querySelectorAll('.custom-input');
|
|
customInputs.forEach(input => {{
|
|
input.addEventListener('keypress', (e) => {{
|
|
if (e.key === 'Enter') {{
|
|
// Extraire les informations de l'ID
|
|
const inputId = input.id;
|
|
const parts = inputId.replace('custom-', '').split('-');
|
|
const errorType = parts[0];
|
|
const errorIndex = parts[parts.length - 1];
|
|
const chapterTitle = parts.slice(1, parts.length - 1).join(' ');
|
|
|
|
// Appliquer la correction
|
|
applyCustomCorrection(errorType, chapterTitle, errorIndex);
|
|
}}
|
|
}});
|
|
}});
|
|
}}
|
|
|
|
// Fonction pour ignorer une erreur
|
|
function ignoreError(errorType, chapterTitle, errorIndex) {{
|
|
// Préparer les données à envoyer
|
|
const data = {{
|
|
action: 'ignore_error',
|
|
error_type: errorType,
|
|
chapter: chapterTitle,
|
|
error_index: errorIndex
|
|
}};
|
|
|
|
// Envoyer la requête au serveur
|
|
fetch('/api/corrections', {{
|
|
method: 'POST',
|
|
headers: {{
|
|
'Content-Type': 'application/json',
|
|
}},
|
|
body: JSON.stringify(data)
|
|
}})
|
|
.then(response => response.json())
|
|
.then(data => {{
|
|
if (data.success) {{
|
|
// Afficher un message de succès
|
|
const card = document.querySelector(`#${{errorType}}-${{chapterTitle.replace(/\\s+/g, '-')}}-${{errorIndex}}`);
|
|
const successMsg = card.querySelector('.success-message');
|
|
successMsg.textContent = 'Erreur ignorée avec succès!';
|
|
successMsg.style.display = 'block';
|
|
|
|
// Masquer le message après 3 secondes
|
|
setTimeout(() => {{
|
|
card.style.display = 'none';
|
|
}}, 1000);
|
|
}} else {{
|
|
// Afficher un message d'erreur
|
|
const card = document.querySelector(`#${{errorType}}-${{chapterTitle.replace(/\\s+/g, '-')}}-${{errorIndex}}`);
|
|
const errorMsg = card.querySelector('.error-message');
|
|
errorMsg.textContent = data.message || 'Erreur lors de l\\'ignorance de l\\'erreur.';
|
|
errorMsg.style.display = 'block';
|
|
|
|
// Masquer le message après 3 secondes
|
|
setTimeout(() => {{
|
|
errorMsg.style.display = 'none';
|
|
}}, 3000);
|
|
}}
|
|
}})
|
|
.catch(error => {{
|
|
console.error('Erreur:', error);
|
|
alert('Une erreur est survenue lors de la communication avec le serveur.');
|
|
}});
|
|
}}
|
|
|
|
// Fonction pour ajouter un mot au dictionnaire personnalisé
|
|
function addToDictionary(word) {{
|
|
// Préparer les données à envoyer
|
|
const data = {{
|
|
action: 'add_to_dictionary',
|
|
word: word
|
|
}};
|
|
|
|
// Envoyer la requête au serveur
|
|
fetch('/api/corrections', {{
|
|
method: 'POST',
|
|
headers: {{
|
|
'Content-Type': 'application/json',
|
|
}},
|
|
body: JSON.stringify(data)
|
|
}})
|
|
.then(response => response.json())
|
|
.then(data => {{
|
|
if (data.success) {{
|
|
// Masquer toutes les cartes d'erreur pour ce mot
|
|
const cards = document.querySelectorAll(`.error-card[data-word="${{word}}"]`);
|
|
cards.forEach(card => {{
|
|
const successMsg = card.querySelector('.success-message');
|
|
successMsg.textContent = 'Mot ajouté au dictionnaire personnalisé!';
|
|
successMsg.style.display = 'block';
|
|
|
|
// Masquer la carte après 1 seconde
|
|
setTimeout(() => {{
|
|
card.style.display = 'none';
|
|
}}, 1000);
|
|
}});
|
|
}} else {{
|
|
// Afficher un message d'erreur
|
|
alert(data.message || 'Erreur lors de l\\'ajout du mot au dictionnaire.');
|
|
}}
|
|
}})
|
|
.catch(error => {{
|
|
console.error('Erreur:', error);
|
|
alert('Une erreur est survenue lors de la communication avec le serveur.');
|
|
}});
|
|
}}
|
|
|
|
// Fonction pour changer d'onglet
|
|
function changeTab(tabName) {{
|
|
// Masquer tous les contenus d'onglets
|
|
const tabContents = document.querySelectorAll('.tab-content');
|
|
tabContents.forEach(content => {{
|
|
content.classList.remove('active');
|
|
}});
|
|
|
|
// Désactiver tous les onglets
|
|
const tabs = document.querySelectorAll('.tab');
|
|
tabs.forEach(tab => {{
|
|
tab.classList.remove('active');
|
|
}});
|
|
|
|
// Activer l'onglet sélectionné
|
|
document.getElementById(tabName).classList.add('active');
|
|
document.querySelector(`.tab[data-tab="${{tabName}}"]`).classList.add('active');
|
|
}}
|
|
|
|
// Initialiser la page quand elle est chargée
|
|
document.addEventListener('DOMContentLoaded', () => {{
|
|
// Activer le premier onglet par défaut
|
|
changeTab('spelling-tab');
|
|
|
|
// Ajouter des écouteurs d'événements pour les onglets
|
|
const tabs = document.querySelectorAll('.tab');
|
|
tabs.forEach(tab => {{
|
|
tab.addEventListener('click', () => {{
|
|
changeTab(tab.getAttribute('data-tab'));
|
|
}});
|
|
}});
|
|
|
|
// Configurer les champs de saisie personnalisée
|
|
setupCustomInputs();
|
|
}});
|
|
"""
|
|
|
|
with open(os.path.join(JS_DIR, 'corrections.js'), 'w', encoding='utf-8') as f:
|
|
f.write(js_content)
|
|
|
|
def create_html(errors_by_chapter):
|
|
"""Crée le fichier HTML pour la page de corrections."""
|
|
html_content = f"""<!DOCTYPE html>
|
|
<html lang="fr">
|
|
<head>
|
|
<meta charset="UTF-8">
|
|
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
|
<title>Corrections Orthographiques et Grammaticales</title>
|
|
<link rel="stylesheet" href="static/css/corrections.css">
|
|
</head>
|
|
<body>
|
|
<header>
|
|
<h1>Corrections Orthographiques et Grammaticales</h1>
|
|
<p>Dernière mise à jour: {datetime.now().strftime('%Y-%m-%d %H:%M')}</p>
|
|
</header>
|
|
|
|
<div class="container">
|
|
<div class="tabs">
|
|
<div class="tab active" data-tab="spelling-tab">Erreurs d'orthographe</div>
|
|
<div class="tab" data-tab="grammar-tab">Erreurs grammaticales</div>
|
|
</div>
|
|
|
|
<div id="spelling-tab" class="tab-content active">
|
|
<h2>Erreurs d'orthographe</h2>
|
|
|
|
{generate_spelling_html(errors_by_chapter)}
|
|
</div>
|
|
|
|
<div id="grammar-tab" class="tab-content">
|
|
<h2>Erreurs grammaticales</h2>
|
|
|
|
{generate_grammar_html(errors_by_chapter)}
|
|
</div>
|
|
</div>
|
|
|
|
<script src="static/js/corrections.js"></script>
|
|
</body>
|
|
</html>
|
|
"""
|
|
|
|
with open(os.path.join('build', 'corrections.html'), 'w', encoding='utf-8') as f:
|
|
f.write(html_content)
|
|
|
|
def generate_spelling_html(errors_by_chapter):
|
|
"""Génère le HTML pour les erreurs d'orthographe."""
|
|
html = ""
|
|
|
|
for chapter_title, errors in errors_by_chapter.items():
|
|
spelling_errors = errors['spelling']
|
|
|
|
if spelling_errors:
|
|
html += f"""
|
|
<div class="chapter-section">
|
|
<h3>{chapter_title}</h3>
|
|
"""
|
|
|
|
for i, error in enumerate(spelling_errors):
|
|
word = error['word']
|
|
suggestions = error['suggestions']
|
|
|
|
html += f"""
|
|
<div id="spelling-{chapter_title.replace(' ', '-')}-{i}" class="error-card spelling" data-word="{word}">
|
|
<h4>Mot mal orthographié: <span class="error-word">{word}</span></h4>
|
|
"""
|
|
|
|
# Ajouter le contexte s'il existe
|
|
if 'context' in error:
|
|
html += f"""
|
|
<div class="error-context">
|
|
{error['context'].replace(word, f'<span class="error-word">{word}</span>')}
|
|
</div>
|
|
"""
|
|
|
|
# Ajouter le contexte étendu s'il existe
|
|
if 'extended_context' in error:
|
|
html += f"""
|
|
<div class="extended-context">
|
|
<h5>Contexte étendu:</h5>
|
|
<pre>{error['extended_context']}</pre>
|
|
</div>
|
|
"""
|
|
|
|
html += f"""
|
|
<div class="suggestion-buttons">
|
|
"""
|
|
|
|
if suggestions:
|
|
for suggestion in suggestions:
|
|
html += f"""
|
|
<button class="suggestion-btn" onclick="applyCorrection('spelling', '{chapter_title}', {i}, '{suggestion}')">{suggestion}</button>
|
|
"""
|
|
else:
|
|
html += """
|
|
<p>Aucune suggestion disponible</p>
|
|
"""
|
|
|
|
html += f"""
|
|
</div>
|
|
|
|
<div class="custom-correction">
|
|
<h5>Correction personnalisée:</h5>
|
|
<div class="input-group">
|
|
<input type="text" id="custom-spelling-{chapter_title.replace(' ', '-')}-{i}" class="custom-input" placeholder="Entrez votre correction">
|
|
<button class="custom-btn" onclick="applyCustomCorrection('spelling', '{chapter_title}', {i})">Appliquer</button>
|
|
</div>
|
|
</div>
|
|
|
|
<div class="action-buttons">
|
|
<button class="action-btn ignore" onclick="ignoreError('spelling', '{chapter_title}', {i})">Ignorer cette erreur</button>
|
|
<button class="action-btn dictionary" onclick="addToDictionary('{word}')">Ajouter au dictionnaire</button>
|
|
</div>
|
|
|
|
<div class="success-message"></div>
|
|
<div class="error-message"></div>
|
|
</div>
|
|
"""
|
|
|
|
html += """
|
|
</div>
|
|
"""
|
|
|
|
return html
|
|
|
|
def generate_grammar_html(errors_by_chapter):
|
|
"""Génère le HTML pour les erreurs grammaticales."""
|
|
html = ""
|
|
|
|
for chapter_title, errors in errors_by_chapter.items():
|
|
grammar_errors = errors['grammar']
|
|
|
|
if grammar_errors:
|
|
html += f"""
|
|
<div class="chapter-section">
|
|
<h3>{chapter_title}</h3>
|
|
"""
|
|
|
|
for i, error in enumerate(grammar_errors):
|
|
message = error['message']
|
|
context = error['context']
|
|
error_text = error['error_text']
|
|
suggestions = error['suggestions']
|
|
|
|
# Mettre en évidence l'erreur dans le contexte
|
|
highlighted_context = context.replace(error_text, f'<span class="error-word">{error_text}</span>')
|
|
|
|
html += f"""
|
|
<div id="grammar-{chapter_title.replace(' ', '-')}-{i}" class="error-card grammar">
|
|
<h4>{message}</h4>
|
|
|
|
<div class="error-context">
|
|
{highlighted_context}
|
|
</div>
|
|
"""
|
|
|
|
# Ajouter le contexte étendu s'il existe
|
|
if 'extended_context' in error:
|
|
html += f"""
|
|
<div class="extended-context">
|
|
<h5>Contexte étendu:</h5>
|
|
<pre>{error['extended_context']}</pre>
|
|
</div>
|
|
"""
|
|
|
|
html += f"""
|
|
<div class="suggestion-buttons">
|
|
"""
|
|
|
|
if suggestions:
|
|
for suggestion in suggestions:
|
|
html += f"""
|
|
<button class="suggestion-btn" onclick="applyCorrection('grammar', '{chapter_title}', {i}, '{suggestion}')">{suggestion}</button>
|
|
"""
|
|
else:
|
|
html += """
|
|
<p>Aucune suggestion disponible</p>
|
|
"""
|
|
|
|
html += f"""
|
|
</div>
|
|
|
|
<div class="custom-correction">
|
|
<h5>Correction personnalisée:</h5>
|
|
<div class="input-group">
|
|
<input type="text" id="custom-grammar-{chapter_title.replace(' ', '-')}-{i}" class="custom-input" placeholder="Entrez votre correction">
|
|
<button class="custom-btn" onclick="applyCustomCorrection('grammar', '{chapter_title}', {i})">Appliquer</button>
|
|
</div>
|
|
</div>
|
|
|
|
<div class="action-buttons">
|
|
<button class="action-btn ignore" onclick="ignoreError('grammar', '{chapter_title}', {i})">Ignorer cette erreur</button>
|
|
</div>
|
|
|
|
<div class="success-message"></div>
|
|
<div class="error-message"></div>
|
|
</div>
|
|
"""
|
|
|
|
html += """
|
|
</div>
|
|
"""
|
|
|
|
return html
|
|
|
|
def main():
|
|
print("Génération de la page de corrections...")
|
|
|
|
# Définir les chemins des fichiers
|
|
report_path = 'rapport_orthographe_grammaire.md'
|
|
|
|
# Vérifier si le rapport existe
|
|
if not os.path.exists(report_path):
|
|
print(f"Erreur: Le fichier {report_path} n'existe pas.")
|
|
return
|
|
|
|
# Parser le rapport d'erreurs
|
|
errors_by_chapter = parse_error_report(report_path)
|
|
|
|
# Créer les fichiers CSS et JS
|
|
create_css()
|
|
create_js(errors_by_chapter)
|
|
|
|
# Créer le fichier HTML
|
|
create_html(errors_by_chapter)
|
|
|
|
print("Page de corrections générée avec succès dans le dossier 'build'.")
|
|
print("Fichier généré: build/corrections.html")
|
|
|
|
if __name__ == "__main__":
|
|
main() |