Détecter les modifications de numérotation lors de la comparaison de fichiers Word en Python

Lorsque vous comparez deux fichiers Word et que la seule différence réside dans la façon dont une liste est numérotée, par exemple des clauses qui étaient 1. et 2. sont maintenant a. et b., ou qu’une liste numérotée est devenue une liste à puces, Aspose.Words ne signale aucune différence par défaut. Ce tutoriel vous montre comment détecter les changements de numérotation lors de la comparaison de fichiers Word en Python. Il explique également comment examiner, accepter ou rejeter les modifications détectées.

Points clés

Par défaut, une modification du style de numérotation ou du caractère de puce d’une liste ne génère aucune révision lors de la comparaison de fichiers Word.
Définir options.advanced_options.compare_list_definitions = True signale chaque paragraphe de liste concerné comme une révision FORMAT_CHANGE.
Les modifications de texte à l’intérieur des éléments de liste sont toujours signalées. L’option ajoute uniquement les changements de numérotation et de puces en plus.
ignore_formatting=True masque les changements de numérotation même lorsque l’option est activée.

Pourquoi les modifications de numérotation n’apparaissent pas par défaut

La numérotation et les puces dans Word proviennent d’une définition de liste. Elle décrit l’apparence de chaque niveau de liste : le style de numéro (1., a., i.), le caractère de puce et le formatage associé. Lorsque vous comparez des documents, Aspose.Words suit Microsoft Word par défaut et exclut les définitions de liste de la comparaison. Ainsi, si seule la numérotation a changé, la comparaison ne signale rien.

L’option compare_list_definitions n’a pas d’équivalent dans Word. Elle indique à Aspose.Words d’inclure les définitions de listes dans la comparaison. Voici ce que nous avons observé en comparant des listes à deux éléments dans la version 26.9 :

Liste originale	Liste modifiée	Option désactivée	Option activée
Numéroté `1.` `2.`	À puces	0 révisions	2 `FORMAT_CHANGE`
Numéroté `1.` `2.`	Lettres `a.` `b.`	0 révisions	2 `FORMAT_CHANGE`
Numéroté, “Élément 2”	À puces, “Élément deux”	2 (`DELETION`, `INSERTION`)	4 (ajoute 2 `FORMAT_CHANGE`)
Numéroté	Liste numérotée identique	0 révisions	0 révisions

La dernière ligne compte en pratique. Activer l’option ne crée pas de révisions supplémentaires pour les listes qui sont identiques dans les deux fichiers.

Prérequis

Vous avez besoin de Aspose.Words for Python via .NET 26.9 ou d’une version ultérieure. Installez‑le ou mettez‑le à jour depuis PyPI:

pip install --upgrade "aspose-words>=26.9"

Sans licence, Aspose.Words fonctionne en mode d’évaluation avec des limitations. Une licence temporaire les supprime pendant vos tests.

Voir la différence : les changements de numérotation avec et sans l’option

Le script suivant crée deux documents contenant les mêmes deux éléments. Le premier utilise une liste numérotée, et le second utilise une liste à puces. Il les compare deux fois, une fois avec l’option désactivée et une fois avec l’option activée, afin que vous puissiez voir exactement ce que l’option modifie.

import datetime
import aspose.words as aw

def build_list_document(bulleted: bool) -> aw.Document:
    """Create a two-item list, either numbered or bulleted."""
    doc = aw.Document()
    builder = aw.DocumentBuilder(doc=doc)
    if bulleted:
        builder.list_format.apply_bullet_default()
    else:
        builder.list_format.apply_number_default()
    builder.writeln("Item 1")
    builder.writeln("Item 2")
    builder.list_format.remove_numbers()
    return doc

def compare_lists(compare_list_definitions: bool) -> aw.Document:
    original = build_list_document(bulleted=False)
    edited = build_list_document(bulleted=True)

options = aw.comparing.CompareOptions()
    options.advanced_options.compare_list_definitions = compare_list_definitions

# compare() writes revisions into `original`; it returns nothing.
    original.compare(
        document=edited,
        author="Reviewer",
        date_time=datetime.datetime.now(),
        options=options,
    )
    return original

for flag in (False, True):
    result = compare_lists(flag)
    print(f"compare_list_definitions={flag}: {result.revisions.count} revision(s)")
    for revision in result.revisions:
        revision_type = aw.RevisionType(revision.revision_type).name
        text = revision.parent_node.get_text().strip()
        print(f"  {revision_type}: {text}")

result.save("compared-lists.docx")

L’exécution du script affiche :

compare_list_definitions=False: 0 revision(s)
compare_list_definitions=True: 2 revision(s)
  FORMAT_CHANGE: Item 1
  FORMAT_CHANGE: Item 2

Comment le code fonctionne

build_list_document utilise DocumentBuilder.list_format pour démarrer une liste numérotée ou à puces par défaut, écrit deux éléments, puis appelle remove_numbers() afin que les paragraphes suivants ne fassent pas partie de la liste.
CompareOptions.advanced_options expose compare_list_definitions, qui est à False par défaut.
original.compare(...) compare original à edited et enregistre les différences sous forme de révisions dans original. La méthode renvoie None, il faut donc toujours lire les résultats depuis le document sur lequel vous l’avez appelée.
parent_node de chaque révision est le paragraphe de liste dont le format a changé. revision_type est RevisionType.FORMAT_CHANGE pour les changements de numérotation et de puces.

Détecter les modifications de numérotation entre deux fichiers Word

Dans un flux de travail réel, vous comparez deux fichiers existants, comme deux versions d’un contrat. Ces comparaisons contiennent généralement d’autres révisions également, de sorte que le script ci‑dessous ne conserve que les changements de mise en forme qui se trouvent sur les paragraphes de liste.

import datetime
import aspose.words as aw

original = aw.Document("contract-v1.docx")
edited = aw.Document("contract-v2.docx")

options = aw.comparing.CompareOptions()
options.advanced_options.compare_list_definitions = True

original.compare(edited, "Reviewer", datetime.datetime.now(), options)

# Keep only formatting revisions that sit on list paragraphs.
list_changes = [
    rev for rev in original.revisions
    if rev.revision_type == aw.RevisionType.FORMAT_CHANGE
    and rev.parent_node is not None
    and rev.parent_node.node_type == aw.NodeType.PARAGRAPH
    and rev.parent_node.as_paragraph().list_format.is_list_item
]

print(f"Total revisions: {original.revisions.count}")
print(f"Formatting changes on list paragraphs: {len(list_changes)}")
for rev in list_changes:
    print(f"  {rev.parent_node.get_text().strip()}")

original.save("contract-compared.docx")

Dans notre test, la version 2 du contrat a transformé une liste numérotée en puces et a également mis en gras une phrase non liée. Le résultat était :

Total revisions: 5
Formatting changes on list paragraphs: 2
  Invoices are due in 30 days.
  Late fees apply after 45 days.

Le filtre sélectionne les deux éléments de liste et ignore le changement en gras, car cette révision s’applique au texte plutôt qu’à un paragraphe de liste. Gardez à l’esprit qu’il correspond à tout changement de mise en forme au niveau du paragraphe sur un élément de liste, comme un retrait modifié, et pas seulement à la numérotation. Vérifiez le document enregistré si vous devez les différencier.

Réviser, accepter ou rejeter les modifications de numérotation

Parce que les modifications de numérotation sont des révisions de format ordinaires, vous les traitez de la même manière que toute autre révision :

revisions.accept_all() applique le format de liste modifié. Dans le premier exemple, les deux éléments deviennent des puces.
revisions.reject_all() conserve le format d’origine, de sorte que les éléments restent numérotés 1. et 2..
Enregistrer le document écrit les révisions en tant que modifications suivies, de sorte que les réviseurs peuvent ouvrir le fichier dans Microsoft Word et décider de chaque modification eux‑mêmes.

Vous pouvez également appeler accept() ou reject() sur des objets Revision individuels, par exemple uniquement sur les éléments de la liste list_changes de la section précédente.

Quand détecter les changements de numérotation

Activez l’option lorsque la numérotation d’une liste a une signification pour vos relecteurs. Les documents juridiques et de politique sont un cas courant : renuméroter les clauses de 1. à (a) modifie la façon dont d’autres documents s’y réfèrent, de sorte qu’un relecteur doit le voir. C’est également utile lorsque vous migrez des documents entre systèmes et que vous souhaitez vérifier que la numérotation des listes est restée inchangée après le transfert.

Désactivez‑le lorsque vous ne vous souciez que du texte. Les revues de contenu, les vérifications de traduction et les différences au niveau du texte sont plus faciles à lire sans les révisions de mise en forme mélangées.

Points à surveiller

ignore_formatting remplace l’option. Si vous définissez options.ignore_formatting = True, les changements de numérotation ne sont pas signalés, même avec compare_list_definitions = True.
Les fichiers ne doivent pas contenir de révisions avant de les comparer. Si l’un des documents possède déjà des modifications suivies, compare lève une RuntimeError indiquant que les documents comparés ne doivent pas contenir de révisions. Acceptez ou rejetez d’abord les révisions existantes. Cela signifie également que vous ne pouvez pas effectuer une seconde comparaison sur un document qui contient déjà les résultats de la première ; rechargez les fichiers à chaque fois.
D’autres révisions apparaissent toujours. Le texte inséré ou supprimé dans un élément de liste est signalé que l’option soit activée ou désactivée, donc vérifiez revision_type si vous devez séparer les changements de numérotation des changements de texte.

Étapes suivantes

L’article Comparer des documents dans la documentation Aspose.Words for Python couvre les autres paramètres de comparaison, y compris la granularité, la cible de comparaison et les options d’ignorance.

FAQ

Pourquoi Aspose.Words ne détecte-t-il pas les changements de numérotation lors de la comparaison de fichiers Word ? Par défaut, Aspose.Words suit Microsoft Word et exclut les définitions de listes, telles que le style de numérotation ou le caractère de puce, de la comparaison. Une liste qui passe de chiffres à puces ne génère aucune révision à moins d’activer compare_list_definitions.
Comment détecter les changements de numérotation en Python ? Créez CompareOptions, définissez options.advanced_options.compare_list_definitions sur True et transmettez les options à Document.compare. Chaque paragraphe de liste dont la numérotation ou la puce a changé reçoit une révision FORMAT_CHANGE.
Quel type de révision crée un changement de numérotation ? Chaque paragraphe de liste concerné reçoit une révision de type RevisionType.FORMAT_CHANGE. L’accepter applique le format de liste du fichier modifié, et le refuser conserve l’original.
L’option fonctionne-t-elle avec ignore_formatting ? Non. Lorsque CompareOptions.ignore_formatting est True, les modifications de numérotation ne sont pas signalées, même si compare_list_definitions est True.
Que renvoie Document.compare ? Rien. Il écrit les différences sous forme de révisions dans le document sur lequel vous l’appelez, de sorte que vous les lisez depuis la collection revisions de ce document.
Quelle version d’Aspose.Words for Python a ajouté cette option ? La propriété compare_list_definitions de AdvancedCompareOptions a été ajoutée dans Aspose.Words for Python via .NET 26.9.

Points clés#

Pourquoi les modifications de numérotation n’apparaissent pas par défaut#

Prérequis#

Voir la différence : les changements de numérotation avec et sans l’option#

Comment le code fonctionne#

Détecter les modifications de numérotation entre deux fichiers Word#

Réviser, accepter ou rejeter les modifications de numérotation#

Quand détecter les changements de numérotation#

Points à surveiller#

Étapes suivantes#

FAQ#

Obtenez une licence gratuite et le support#