278 lines
9.3 KiB
Python
278 lines
9.3 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Script de remplacement de texte dans des fichiers .docx
|
|
Lit un fichier YAML de configuration et applique les remplacements
|
|
dans tous les .docx d'un dossier en préservant le formatage.
|
|
"""
|
|
|
|
import sys
|
|
import os
|
|
import shutil
|
|
import yaml
|
|
from docx import Document
|
|
from copy import deepcopy
|
|
|
|
|
|
def get_full_text_from_runs(runs):
|
|
"""Reconstitue le texte complet à partir des runs."""
|
|
return "".join(r.text for r in runs)
|
|
|
|
|
|
def replace_in_runs(runs, ancien, nouveau):
|
|
"""
|
|
Remplace du texte dans une liste de runs en préservant le formatage.
|
|
Gère le cas où le texte est découpé sur plusieurs runs.
|
|
Retourne le nombre de remplacements effectués.
|
|
"""
|
|
count = 0
|
|
full_text = get_full_text_from_runs(runs)
|
|
|
|
if ancien not in full_text:
|
|
return 0
|
|
|
|
while ancien in full_text:
|
|
count += 1
|
|
start_idx = full_text.index(ancien)
|
|
end_idx = start_idx + len(ancien)
|
|
|
|
# Trouver quels runs sont concernés
|
|
char_pos = 0
|
|
start_run = None
|
|
end_run = None
|
|
|
|
for i, run in enumerate(runs):
|
|
run_start = char_pos
|
|
run_end = char_pos + len(run.text)
|
|
|
|
if start_run is None and run_end > start_idx:
|
|
start_run = i
|
|
start_offset = start_idx - run_start
|
|
|
|
if run_end >= end_idx:
|
|
end_run = i
|
|
end_offset = end_idx - run_start
|
|
break
|
|
|
|
char_pos = run_end
|
|
|
|
if start_run is None or end_run is None:
|
|
break
|
|
|
|
# Cas simple : tout dans un seul run
|
|
if start_run == end_run:
|
|
run = runs[start_run]
|
|
run.text = run.text[:start_offset] + nouveau + run.text[end_offset:]
|
|
else:
|
|
# Multi-run : mettre le nouveau texte dans le premier run,
|
|
# vider les runs intermédiaires, ajuster le dernier
|
|
runs[start_run].text = runs[start_run].text[:start_offset] + nouveau
|
|
|
|
for i in range(start_run + 1, end_run):
|
|
runs[i].text = ""
|
|
|
|
runs[end_run].text = runs[end_run].text[end_offset:]
|
|
|
|
full_text = get_full_text_from_runs(runs)
|
|
|
|
return count
|
|
|
|
|
|
def replace_in_paragraph(paragraph, ancien, nouveau):
|
|
"""Remplace du texte dans un paragraphe."""
|
|
if not paragraph.runs:
|
|
return 0
|
|
return replace_in_runs(paragraph.runs, ancien, nouveau)
|
|
|
|
|
|
def replace_in_table(table, ancien, nouveau):
|
|
"""Remplace du texte dans toutes les cellules d'un tableau."""
|
|
count = 0
|
|
for row in table.rows:
|
|
for cell in row.cells:
|
|
for paragraph in cell.paragraphs:
|
|
count += replace_in_paragraph(paragraph, ancien, nouveau)
|
|
# Tables imbriquées
|
|
for nested_table in cell.tables:
|
|
count += replace_in_table(nested_table, ancien, nouveau)
|
|
return count
|
|
|
|
|
|
def replace_in_headers_footers(doc, ancien, nouveau):
|
|
"""Remplace du texte dans les en-têtes et pieds de page."""
|
|
count = 0
|
|
for section in doc.sections:
|
|
for header in [section.header, section.first_page_header, section.even_page_header]:
|
|
if header and header.is_linked_to_previous is False:
|
|
for paragraph in header.paragraphs:
|
|
count += replace_in_paragraph(paragraph, ancien, nouveau)
|
|
for table in header.tables:
|
|
count += replace_in_table(table, ancien, nouveau)
|
|
|
|
for footer in [section.footer, section.first_page_footer, section.even_page_footer]:
|
|
if footer and footer.is_linked_to_previous is False:
|
|
for paragraph in footer.paragraphs:
|
|
count += replace_in_paragraph(paragraph, ancien, nouveau)
|
|
for table in footer.tables:
|
|
count += replace_in_table(table, ancien, nouveau)
|
|
return count
|
|
|
|
|
|
def process_docx(filepath, remplacements):
|
|
"""Applique tous les remplacements sur un fichier .docx."""
|
|
doc = Document(filepath)
|
|
rapport = {}
|
|
|
|
for remp in remplacements:
|
|
ancien = remp["ancien"]
|
|
nouveau = remp["nouveau"]
|
|
fichiers_cibles = remp.get("fichiers", None)
|
|
|
|
# Si des fichiers cibles sont spécifiés, vérifier que ce fichier en fait partie
|
|
if fichiers_cibles:
|
|
basename = os.path.basename(filepath)
|
|
if basename not in fichiers_cibles:
|
|
continue
|
|
|
|
count = 0
|
|
|
|
# Paragraphes du corps
|
|
for paragraph in doc.paragraphs:
|
|
count += replace_in_paragraph(paragraph, ancien, nouveau)
|
|
|
|
# Tableaux
|
|
for table in doc.tables:
|
|
count += replace_in_table(table, ancien, nouveau)
|
|
|
|
# En-têtes et pieds de page
|
|
count += replace_in_headers_footers(doc, ancien, nouveau)
|
|
|
|
if count > 0:
|
|
rapport[f"'{ancien}' -> '{nouveau}'"] = count
|
|
|
|
doc.save(filepath)
|
|
return rapport
|
|
|
|
|
|
def main():
|
|
if len(sys.argv) < 2:
|
|
print("Usage: python3 replace_docx.py <fichier_config.yaml>")
|
|
sys.exit(1)
|
|
|
|
config_path = os.path.abspath(sys.argv[1])
|
|
config_dir = os.path.dirname(config_path)
|
|
|
|
with open(config_path, "r", encoding="utf-8") as f:
|
|
config = yaml.safe_load(f)
|
|
|
|
# Les chemins sont relatifs à la racine du projet (dossier contenant replace_docx.py)
|
|
project_dir = os.path.dirname(os.path.abspath(__file__))
|
|
|
|
dossier_source = config["dossier_source"]
|
|
if not os.path.isabs(dossier_source):
|
|
dossier_source = os.path.join(project_dir, dossier_source)
|
|
|
|
remplacements = config["remplacements"]
|
|
|
|
# Le dossier de travail est celui qui contient le fichier YAML
|
|
dossier_travail = config_dir
|
|
|
|
# Copier les .docx du template dans le dossier de travail (y compris sous-dossiers)
|
|
docx_copies = 0
|
|
for root, dirs, files in os.walk(dossier_source):
|
|
for f in files:
|
|
if f.endswith(".docx") and not f.startswith("~$"):
|
|
src = os.path.join(root, f)
|
|
# Reproduire la structure de sous-dossiers
|
|
rel = os.path.relpath(src, dossier_source)
|
|
dst = os.path.join(dossier_travail, rel)
|
|
os.makedirs(os.path.dirname(dst), exist_ok=True)
|
|
if not os.path.exists(dst):
|
|
shutil.copy2(src, dst)
|
|
docx_copies += 1
|
|
|
|
if docx_copies > 0:
|
|
print(f"{docx_copies} fichier(s) .docx copie(s) depuis {dossier_source}")
|
|
else:
|
|
print(f"Fichiers .docx deja presents dans {dossier_travail}")
|
|
|
|
# Trouver tous les .docx du dossier de travail (y compris sous-dossiers)
|
|
docx_files = []
|
|
for root, dirs, files in os.walk(dossier_travail):
|
|
for f in files:
|
|
if f.endswith(".docx") and not f.startswith("~$"):
|
|
docx_files.append(os.path.join(root, f))
|
|
|
|
if not docx_files:
|
|
print("Aucun fichier .docx trouve.")
|
|
sys.exit(1)
|
|
|
|
print(f"\n{len(docx_files)} fichier(s) .docx trouve(s)\n")
|
|
|
|
# Appliquer les remplacements
|
|
rapport_global = {}
|
|
for filepath in sorted(docx_files):
|
|
rapport = process_docx(filepath, remplacements)
|
|
rel_path = os.path.relpath(filepath, dossier_travail)
|
|
rapport_global[rel_path] = rapport
|
|
|
|
# Identifier les remplacements non trouves
|
|
remplacements_non_trouves = set()
|
|
for remp in remplacements:
|
|
cle = f"'{remp['ancien']}' -> '{remp['nouveau']}'"
|
|
trouve = False
|
|
for fichier, rapport in rapport_global.items():
|
|
if cle in rapport:
|
|
trouve = True
|
|
break
|
|
if not trouve:
|
|
remplacements_non_trouves.add(cle)
|
|
|
|
# Generer le rapport markdown
|
|
from datetime import datetime
|
|
lignes = []
|
|
lignes.append(f"# Rapport de modifications")
|
|
lignes.append(f"")
|
|
lignes.append(f"**Date** : {datetime.now().strftime('%d/%m/%Y %H:%M')}")
|
|
lignes.append(f"**Template** : `{os.path.relpath(dossier_source, project_dir)}`")
|
|
lignes.append(f"**Fichiers traites** : {len(docx_files)}")
|
|
lignes.append(f"")
|
|
|
|
lignes.append(f"## Modifications par fichier")
|
|
lignes.append(f"")
|
|
for fichier, rapport in sorted(rapport_global.items()):
|
|
lignes.append(f"### {fichier}")
|
|
lignes.append(f"")
|
|
if rapport:
|
|
lignes.append(f"| Ancien | Nouveau | Occurrences |")
|
|
lignes.append(f"|---|---|---|")
|
|
for remp, count in rapport.items():
|
|
# remp est au format "'ancien' -> 'nouveau'"
|
|
parties = remp.split("' -> '")
|
|
ancien_txt = parties[0][1:] # enlever le ' du debut
|
|
nouveau_txt = parties[1][:-1] # enlever le ' de la fin
|
|
lignes.append(f"| {ancien_txt} | {nouveau_txt} | {count} |")
|
|
else:
|
|
lignes.append(f"Aucun remplacement effectue.")
|
|
lignes.append(f"")
|
|
|
|
if remplacements_non_trouves:
|
|
lignes.append(f"## Remplacements non trouves")
|
|
lignes.append(f"")
|
|
lignes.append(f"Les remplacements suivants n'ont ete trouves dans aucun fichier :")
|
|
lignes.append(f"")
|
|
for r in remplacements_non_trouves:
|
|
lignes.append(f"- {r}")
|
|
lignes.append(f"")
|
|
|
|
# Ecrire le rapport
|
|
rapport_path = os.path.join(dossier_travail, "rapport.md")
|
|
with open(rapport_path, "w", encoding="utf-8") as f:
|
|
f.write("\n".join(lignes))
|
|
|
|
print(f"Rapport genere : {rapport_path}")
|
|
print("Termine!")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|