# GroupDocs.Comparison for Python via .NET — Complete Documentation

> GroupDocs.Comparison for Python via .NET developer documentation. Learn how to diff DOCX, PPTX, XLSX, and PDF files using the Python API.

---

## Compare Documents

Path: /comparison/python-net/developer-guide/comparing-documents/compare-documents/


The change-detection algorithm of [GroupDocs.Comparison](https://products.groupdocs.com/comparison/python-net) detects changes across many document parts and blocks:

- Text blocks — paragraphs, words, and characters.
- Tables.
- Images.
- Shapes.

The result document highlights detected changes with colour:

- Added — **blue**.
- Modified — **green**.
- Style — **green**.
- Deleted — **red**.

The styling scheme is fully customizable — see [Customize changes styles]({{< ref "comparison/python-net/developer-guide/comparing-documents/customize-changes-styles" >}}).

To compare two documents, follow these steps:

1. Instantiate a [`Comparer`](https://reference.groupdocs.com/comparison/python-net/groupdocs.comparison/comparer) with the source document path or stream.
2. Call [`add()`](https://reference.groupdocs.com/comparison/python-net/groupdocs.comparison/comparer/#add) and specify the target document path or stream.
3. Call [`compare()`](https://reference.groupdocs.com/comparison/python-net/groupdocs.comparison/comparer/#compare) and specify the result file path or output stream.

## Example 1: Compare documents from file paths

The simplest way to compare two documents is by passing file paths to `Comparer`.

{{< tabs "compare-documents-path">}}
{{< tab "compare_documents.py" >}}
```python
from groupdocs.comparison import Comparer

def compare_documents():
    # Initialize Comparer with the source file path
    with Comparer("./source.docx") as comparer:
        # Add the target file and run the comparison
        comparer.add("./target.docx")
        comparer.compare("./result.docx")

if __name__ == "__main__":
    compare_documents()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-documents/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-documents/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/compare-documents/compare_documents/result.docx)
{{< /tab >}}
{{< /tabs >}}

The output file looks like this:

![](/comparison/python-net/images/compare-documents.png)

## Example 2: Compare documents from streams

You can also feed `Comparer` open file streams — useful when the source and target arrive over the network, from a database, or from another in-memory source.

{{< tabs "compare-documents-stream">}}
{{< tab "compare_documents_from_stream.py" >}}
```python
from groupdocs.comparison import Comparer

def compare_documents_from_stream():
    # Open the source and target as binary streams
    with open("./source.docx", "rb") as source_stream, \
         open("./target.docx", "rb") as target_stream:
        with Comparer(source_stream) as comparer:
            comparer.add(target_stream)
            comparer.compare("./result.docx")

if __name__ == "__main__":
    compare_documents_from_stream()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-documents/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-documents/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/compare-documents/compare_documents_from_stream/result.docx)
{{< /tab >}}
{{< /tabs >}}

## Example 3: Compare documents and write the result to a stream

Combine input streams with an output stream to keep everything in memory:

{{< tabs "compare-documents-output-stream">}}
{{< tab "compare_documents_to_stream.py" >}}
```python
from groupdocs.comparison import Comparer

def compare_documents_to_stream():
    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")
        with open("./result.docx", "wb") as out_stream:
            comparer.compare(out_stream)

if __name__ == "__main__":
    compare_documents_to_stream()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-documents/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-documents/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/compare-documents/compare_documents_to_stream/result.docx)
{{< /tab >}}
{{< /tabs >}}

## Next steps

- [Compare multiple documents]({{< ref "comparison/python-net/developer-guide/comparing-documents/compare-multiple-documents" >}}) — compare a source against multiple targets.
- [Accept or reject detected changes]({{< ref "comparison/python-net/developer-guide/comparing-documents/accept-or-reject-detected-changes" >}}) — review changes individually before producing the result.
- [Adjusting comparison sensitivity]({{< ref "comparison/python-net/developer-guide/comparing-documents/adjusting-comparison-sensitivity" >}}) — fine-tune the change-detection threshold.
- [Customize changes styles]({{< ref "comparison/python-net/developer-guide/comparing-documents/customize-changes-styles" >}}) — change the highlight colours and styles.

---

## Features Overview

Path: /comparison/python-net/getting-started/features-overview/


GroupDocs.Comparison for Python via .NET is a feature-rich document comparison library. The sections below summarize what the API can do; each one links to the developer-guide topic that covers it in depth.

## File comparison

[GroupDocs.Comparison](https://products.groupdocs.com/comparison/python-net) identifies differences between two or more files at paragraph, word, and character levels. It detects content changes — additions, deletions, modifications — and style and formatting changes such as bold, italic, underline, strikethrough, and font changes.

See: [Compare documents]({{< ref "comparison/python-net/developer-guide/comparing-documents/compare-documents" >}}).

## Multi-document comparison

Compare a source document against multiple targets in a single operation. The merged result aggregates changes from every target, which is useful for collating proposal revisions or multiple reviewer iterations.

See: [Compare multiple documents]({{< ref "comparison/python-net/developer-guide/comparing-documents/compare-multiple-documents" >}}).

## Accept or reject changes

Every detected difference can be accepted or rejected programmatically. The accepted-only result can be saved to a new document, enabling reviewer-style workflows.

See: [Accept or reject detected changes]({{< ref "comparison/python-net/developer-guide/comparing-documents/accept-or-reject-detected-changes" >}}).

## Customize the comparison process

Tune how the comparison runs:

- Sensitivity (per-line, per-word, per-character) — see [Adjusting comparison sensitivity]({{< ref "comparison/python-net/developer-guide/comparing-documents/adjusting-comparison-sensitivity" >}}).
- Highlight colours and styles — see [Customize changes styles]({{< ref "comparison/python-net/developer-guide/comparing-documents/customize-changes-styles" >}}).
- Show or hide gap lines — see [Show gap lines]({{< ref "comparison/python-net/developer-guide/comparing-documents/show-gap-lines" >}}).
- Word track-changes handling — see [Word track changes]({{< ref "comparison/python-net/developer-guide/comparing-documents/word-track-changes" >}}).

## Document information extraction

Without performing a full comparison, query basic metadata: file type, size, and page count. Useful for routing decisions and previews.

See: [Get document information]({{< ref "comparison/python-net/developer-guide/getting-document-info" >}}).

## Page previews

Generate per-page image previews of the source, target, or result document.

See: [Generate document pages preview]({{< ref "comparison/python-net/developer-guide/generate-document-pages-preview" >}}).

## Folder comparison

Compare entire folders of documents in one pass.

See: [Compare folders]({{< ref "comparison/python-net/developer-guide/compare-folders" >}}).

## Summary reports

When comparison completes, you can save a summary page listing every detected change. Combine with [Get extended information on the summary page]({{< ref "comparison/python-net/developer-guide/comparing-documents/get-extended-information-on-the-summary-page" >}}) for richer reports.

## Load and save flexibility

- Load from local files or streams, including password-protected documents and custom fonts — see [Loading documents]({{< ref "comparison/python-net/developer-guide/loading-documents" >}}).
- Save results to file paths or streams; control output format, metadata, and password — see [Saving results]({{< ref "comparison/python-net/developer-guide/saving-results" >}}).

---

## Get Document Information

Path: /comparison/python-net/developer-guide/getting-document-info/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) can return the following information about a document without performing a comparison:

- `file_type` — the document file type (PDF, Word, Excel, PowerPoint, image, etc.).
- `page_count` — number of pages.
- `size` — file size in bytes.
- `pages_info` — per-page information.

## Example 1: Get document info for a file on local disk

{{< tabs "get-document-info-path">}}
{{< tab "get_document_info.py" >}}
```python
from groupdocs.comparison import Comparer

def get_document_info():
    with Comparer("./source.docx") as comparer:
        info = comparer.source.get_document_info()
        print(f"File type: {info.file_type.file_format}")
        print(f"Number of pages: {info.page_count}")
        print(f"Document size: {info.size} bytes")
        print("\nDocument info extracted successfully.")

if __name__ == "__main__":
    get_document_info()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the document used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/getting-document-info/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "get-document-info.txt" >}}  
```text
File type: Microsoft Word Document
Number of pages: 1
Document size: 26611 bytes

Document info extracted successfully.
```
[Download full output](/comparison/python-net/_output_files/developer-guide/getting-document-info/get_document_info/get-document-info.txt)
{{< /tab >}}
{{< /tabs >}}

## Example 2: Get document info for a file from a stream

{{< tabs "get-document-info-stream">}}
{{< tab "get_document_info_from_stream.py" >}}
```python
from groupdocs.comparison import Comparer

def get_document_info_from_stream():
    with open("./source.docx", "rb") as source_stream:
        with Comparer(source_stream) as comparer:
            info = comparer.source.get_document_info()
            print(f"File type: {info.file_type.file_format}")
            print(f"Number of pages: {info.page_count}")
            print(f"Document size: {info.size} bytes")

if __name__ == "__main__":
    get_document_info_from_stream()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the document used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/getting-document-info/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "get-document-info-from-stream.txt" >}}  
```text
File type: Microsoft Word Document
Number of pages: 1
Document size: 26611 bytes
```
[Download full output](/comparison/python-net/_output_files/developer-guide/getting-document-info/get_document_info_from_stream/get-document-info-from-stream.txt)
{{< /tab >}}
{{< /tabs >}}

## Inspect without comparing — the trio

`Comparer.source.get_document_info()` is one of three ways to read information about a document without running a full comparison:

| What you need | Use |
|---|---|
| File type, size, page count of a *specific* document | This page |
| The list of *every* supported format at runtime | [Get supported file formats]({{< ref "comparison/python-net/developer-guide/get-supported-file-formats" >}}) |
| Visual thumbnails of selected pages | [Generate document pages preview]({{< ref "comparison/python-net/developer-guide/generate-document-pages-preview" >}}) |

Pair `get_document_info()` with the format-list to validate inputs early in a pipeline (e.g., reject anything outside an allowlist), and use page previews to give end users a quick visual preview before committing to a full diff.

## Related topics

- [Get supported file formats]({{< ref "comparison/python-net/developer-guide/get-supported-file-formats" >}}) — enumerate supported types at runtime.
- [Generate document pages preview]({{< ref "comparison/python-net/developer-guide/generate-document-pages-preview" >}}) — render page thumbnails.
- [Specify file type for comparison manually]({{< ref "comparison/python-net/developer-guide/comparing-documents/specify-file-type-manually" >}}) — when the inferred type is wrong.

---

## Load File from Local Disk

Path: /comparison/python-net/developer-guide/loading-documents/load-file-from-local-disk/


When source and target files are on the local disk, pass their paths directly to `Comparer` and `add()`. Both absolute and relative paths work.

## Example: Load files from local disk

{{< tabs "load-from-disk">}}
{{< tab "load_file_from_local_disk.py" >}}
```python
from groupdocs.comparison import Comparer

def load_file_from_local_disk():
    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")
        comparer.compare("./result.docx")
        print("Documents compared successfully. Check output in result.docx.")

if __name__ == "__main__":
    load_file_from_local_disk()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/loading-documents/load-file-from-local-disk/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/loading-documents/load-file-from-local-disk/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/loading-documents/load-file-from-local-disk/load_file_from_local_disk/result.docx)
{{< /tab >}}
{{< /tabs >}}

---

## GroupDocs.Comparison for Python via .NET Overview

Path: /comparison/python-net/product-overview/


## What is GroupDocs.Comparison?

GroupDocs.Comparison for Python via .NET is a native Python library that compares **50+ document formats** — DOCX, PDF, XLSX, PPTX, OpenDocument, AutoCAD, Visio, images, HTML, and source code — and reports the differences at paragraph, word, and character level, including style and formatting changes. It runs entirely on-premise, requires no Microsoft Office installation, and ships as a pre-built wheel on Windows, Linux, and macOS.

Typical uses include:

- **Contract and policy review** — surface inserted, deleted, and modified clauses between two DOCX or PDF revisions and route only the changed regions to reviewers (or to an LLM) instead of re-reading both documents.
- **Editorial accept/reject workflows** — classify each detected change, then re-emit the document honouring the decisions via `apply_changes`.
- **AI-edit audit** — compare the document an agent produced against the original to verify and explain every change it made. See [Agents and LLM Integration]({{< ref "comparison/python-net/agents-and-llm-integration" >}}) for the full pipeline.
- **Version-control review** — diff two exports of a non-text-friendly format (PPTX, XLSX, Visio, DWG) without flattening the binary.
- **Multi-source consolidation** — diff one source against many targets in a single pass to spot which downstream copy drifted from the canonical version.

## Key Capabilities

| Capability | Description |
|---|---|
| **50+ comparison formats** | DOCX, PDF, XLSX, PPTX, ODT, HTML, images, AutoCAD, Visio, source code, and more. See [supported formats]({{< ref "comparison/python-net/getting-started/supported-document-formats" >}}). |
| **Granular change detection** | [Paragraph, word, and character-level diffs]({{< ref "comparison/python-net/developer-guide/comparing-documents/compare-documents" >}}) — including style, formatting, and structural changes. |
| **Inspect detected changes** | [Iterate `ChangeInfo` objects]({{< ref "comparison/python-net/developer-guide/comparing-documents/get-list-of-changes" >}}) — type (INSERTED / DELETED / STYLE_CHANGED), text, author, and style deltas — without writing an output file. |
| **Accept / reject workflows** | [Per-change ACCEPT / REJECT decisions]({{< ref "comparison/python-net/developer-guide/comparing-documents/accept-or-reject-detected-changes" >}}) re-emitted via `apply_changes`. |
| **Multi-source comparison** | [Diff one source against multiple targets]({{< ref "comparison/python-net/developer-guide/comparing-documents/compare-multiple-documents" >}}) in a single `Comparer`. |
| **Folder comparison** | [Compare entire directories]({{< ref "comparison/python-net/developer-guide/compare-folders" >}}) with the folder-compare mode. |
| **Change coordinates** | [Get the `Rectangle` (x / y / width / height) of every detected change]({{< ref "comparison/python-net/developer-guide/comparing-documents/get-changes-coordinates" >}}) for overlay rendering. |
| **Custom change styling** | [Style inserted / deleted / changed regions]({{< ref "comparison/python-net/developer-guide/comparing-documents/customize-changes-styles" >}}) with `Color`, RGB tuples, hex strings, or named colours. |
| **Summary pages** | [Append a summary]({{< ref "comparison/python-net/developer-guide/comparing-documents/get-only-summary-page" >}}) with change statistics, or emit a summary-only result. |
| **Password-protected documents** | [Open and re-save protected DOCX / PDF / XLSX]({{< ref "comparison/python-net/developer-guide/loading-documents/load-password-protected-documents" >}}) via `LoadOptions.password` and `SaveOptions.password`. |
| **Streams** | Load input from file-like objects (`open(..., "rb")` or `io.BytesIO`) — handy for cloud blobs and HTTP bodies. |
| **Document inspection** | [Read format, page count, and size]({{< ref "comparison/python-net/developer-guide/getting-document-info" >}}) without running a comparison. |
| **Logging and diagnostics** | [Wire `ConsoleLogger`]({{< ref "comparison/python-net/developer-guide/logging-and-diagnostics" >}}) through `ComparerSettings` for production traces. |
| **On-premise** | No cloud calls, no Microsoft Office install, no network traffic. |

## Quick Example

{{< tabs "quick-example">}}
{{< tab "compare_documents.py" >}}
```python
from groupdocs.comparison import Comparer

def compare_documents():
    """Compare two DOCX revisions and write a tracked-changes result."""
    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")
        comparer.compare("./result.docx")

if __name__ == "__main__":
    compare_documents()
```
{{< /tab >}}
{{< tab "With options" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import CompareOptions, LoadOptions

def compare_with_options():
    """Compare two password-protected DOCX files with style detection
    and a summary page appended to the result."""
    load = LoadOptions()
    load.password = "1234"

    with Comparer("./protected_source.docx", load_options=load) as comparer:
        comparer.add("./protected_target.docx", load_options=load)
        options = CompareOptions()
        options.detect_style_changes = True
        options.generate_summary_page = True
        options.sensitivity_of_comparison = 75
        comparer.compare("./result.docx", options)

if __name__ == "__main__":
    compare_with_options()
```
{{< /tab >}}
{{< tab "result.docx" >}}
{{< tab-text >}}
`result.docx` is the comparison output produced by the `compare_documents.py` snippet. [Download the sample result](/comparison/python-net/_output_files/developer-guide/comparing-documents/compare-documents/compare_documents/result.docx).
{{< /tab-text >}}
{{< /tab >}}
{{< /tabs >}}

## Where to next

1. **Install the package** — [Installation]({{< ref "comparison/python-net/getting-started/installation" >}}) walks through PyPI installation for Windows, Linux, and macOS.
2. **Run your first comparison** — [Quick Start Guide]({{< ref "comparison/python-net/getting-started/quick-start-guide" >}}) compares two DOCX files in five minutes.
3. **Explore the examples** — [Running Examples]({{< ref "comparison/python-net/getting-started/how-to-run-examples" >}}) clones the runnable repository and runs every documented scenario locally.
4. **Use it in depth** — the [Developer Guide]({{< ref "comparison/python-net/developer-guide" >}}) covers loading, comparing, accepting/rejecting changes, multi-source, folder compare, summary pages, and logging.
5. **Plug it into AI pipelines** — [Agents and LLM Integration]({{< ref "comparison/python-net/agents-and-llm-integration" >}}) explains the MCP server, `AGENTS.md`, and how to use Comparison as the change-detection step in agent workflows.

---

## Quick Start Guide

Path: /comparison/python-net/getting-started/quick-start-guide/


This guide walks you through installing GroupDocs.Comparison for Python via .NET and comparing two documents end to end. By the end you will have a working environment, an output file showing the differences between two sample documents, and the code skeleton to extend for your own use cases.

## Prerequisites

- **Python 3.5 or newer** — verify with `python --version`.
- A package manager — pip is bundled with Python.
- Two sample documents to compare. You can [download `source.docx`](/comparison/python-net/_sample_files/getting-started/quick-start-guide/source.docx) and [`target.docx`](/comparison/python-net/_sample_files/getting-started/quick-start-guide/target.docx) used in this guide, or use your own.

On Linux and macOS, GroupDocs.Comparison also requires `libgdiplus` and font support — see the [installation guide]({{< ref "comparison/python-net/getting-started/installation" >}}) for the exact commands.

## Step 1 — Install the package

Install GroupDocs.Comparison from PyPI:

```bash
pip install groupdocs-comparison-net
```

The wheel is roughly 150 MB and bundles the .NET runtime; no further setup is required on Windows.

## Step 2 — Compare two documents

Save the following snippet as `quick_start.py` in the same folder as `source.docx` and `target.docx`, then run it with `python quick_start.py`.

{{< tabs "quick-start">}}
{{< tab "quick_start.py" >}}
```python
from groupdocs.comparison import Comparer

def quick_start():
    # Initialize Comparer with the source document and add the target.
    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")
        # The result file contains the merged comparison highlighting added,
        # deleted, modified, and style changes.
        comparer.compare("./result.docx")

if __name__ == "__main__":
    quick_start()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/getting-started/quick-start-guide/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/getting-started/quick-start-guide/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/getting-started/quick-start-guide/quick_start/result.docx)
{{< /tab >}}
{{< /tabs >}}

Open `result.docx` to see the differences highlighted in colour: insertions in blue, deletions in red, style changes in green.

## Step 3 — Inspect detected changes programmatically

Beyond writing a merged result file, you can iterate over the individual changes:

{{< tabs "quick-start-changes">}}
{{< tab "list_changes.py" >}}
```python
from groupdocs.comparison import Comparer

def list_changes():
    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")
        comparer.compare()
        for change in comparer.get_changes():
            print(f"Type: {change.type}, Text: {change.text}")

if __name__ == "__main__":
    list_changes()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/getting-started/quick-start-guide/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/getting-started/quick-start-guide/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "list-changes.txt" >}}  
```text
Type: 2, Text: Cool
Type: 2, Text:  
Type: 3, Text: test 
Type: 2, Text:  signatures
Type: 2, Text: Our 
Type: 2, Text: char[
Type: 2, Text: 255]
Type: 2, Text:  
Type: 3, Text:
```
[Download full output](/comparison/python-net/_output_files/getting-started/quick-start-guide/list_changes/list-changes.txt)
{{< /tab >}}
{{< /tabs >}}

## Evaluation vs licensed mode

Without a license, GroupDocs.Comparison processes only the first two pages of any document and stamps trial badges on the output. To unlock the full feature set, apply a license — either via the `GROUPDOCS_LIC_PATH` environment variable (zero-code) or by calling `License().set_license(path)`. Request a free 30-day temporary license at [purchase.groupdocs.com/temporary-license](https://purchase.groupdocs.com/temporary-license).

See [Licensing and subscription]({{< ref "comparison/python-net/getting-started/licensing-and-subscription" >}}) for the full set of options, including metered licensing and stream-based license loading.

## Next steps

- [Compare documents]({{< ref "comparison/python-net/developer-guide/comparing-documents/compare-documents" >}}) — the full API surface for two-document comparison.
- [Accept or reject detected changes]({{< ref "comparison/python-net/developer-guide/comparing-documents/accept-or-reject-detected-changes" >}}) — reviewer-style workflows that pick and choose which changes to apply.
- [Customize changes styles]({{< ref "comparison/python-net/developer-guide/comparing-documents/customize-changes-styles" >}}) — change highlight colours, fonts, and decorations.
- [Load documents]({{< ref "comparison/python-net/developer-guide/loading-documents" >}}) — paths, streams, password-protected files, custom fonts.
- [Save comparison results]({{< ref "comparison/python-net/developer-guide/saving-results" >}}) — output format, metadata, output password.
- [AI agents and LLM integration]({{< ref "comparison/python-net/agents-and-llm-integration" >}}) — work with the API from Claude Code, Cursor, and other AI assistants.

---

## Set Document Metadata on Save

Path: /comparison/python-net/developer-guide/saving-results/set-document-metadata-on-save/


The comparison result document can carry metadata (author, organization, creation date, etc.). Use [`SaveOptions.clone_metadata_type`](https://reference.groupdocs.com/comparison/python-net/groupdocs.comparison.options.save/saveoptions/) to choose where it comes from:

- `MetadataType.SOURCE` — clone metadata from the source document.
- `MetadataType.TARGET` — clone metadata from the target document.
- `MetadataType.FILE_AUTHOR` — set user-defined metadata via `SaveOptions.file_author_metadata`.

## Example 1: Use metadata from the source file

{{< tabs "metadata-source">}}
{{< tab "set_metadata_from_source.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import SaveOptions, MetadataType

def set_metadata_from_source():
    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")
        save_options = SaveOptions()
        save_options.clone_metadata_type = MetadataType.SOURCE
        comparer.compare("./result.docx", save_options)

if __name__ == "__main__":
    set_metadata_from_source()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/saving-results/set-document-metadata-on-save/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/saving-results/set-document-metadata-on-save/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/saving-results/set-document-metadata-on-save/set_metadata_from_source/result.docx)
{{< /tab >}}
{{< /tabs >}}

## Example 2: Use metadata from the target file

{{< tabs "metadata-target">}}
{{< tab "set_metadata_from_target.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import SaveOptions, MetadataType

def set_metadata_from_target():
    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")
        save_options = SaveOptions()
        save_options.clone_metadata_type = MetadataType.TARGET
        comparer.compare("./result.docx", save_options)

if __name__ == "__main__":
    set_metadata_from_target()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/saving-results/set-document-metadata-on-save/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/saving-results/set-document-metadata-on-save/set_metadata_from_target/result.docx)
{{< /tab >}}
{{< /tabs >}}

## Example 3: Set user-defined metadata

{{< tabs "metadata-user-defined">}}
{{< tab "set_user_defined_metadata.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import SaveOptions, MetadataType, FileAuthorMetadata

def set_user_defined_metadata():
    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")

        author_metadata = FileAuthorMetadata()
        author_metadata.author = "Tom"
        author_metadata.company = "GroupDocs"
        author_metadata.last_save_by = "Jack"

        save_options = SaveOptions()
        save_options.clone_metadata_type = MetadataType.FILE_AUTHOR
        save_options.file_author_metadata = author_metadata

        comparer.compare("./result.docx", save_options)

if __name__ == "__main__":
    set_user_defined_metadata()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/saving-results/set-document-metadata-on-save/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/saving-results/set-document-metadata-on-save/set_user_defined_metadata/result.docx)
{{< /tab >}}
{{< /tabs >}}

---

## Compare Word Documents

Path: /comparison/python-net/developer-guide/comparing-documents/compare-word-documents/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) compares Word documents and highlights differences in text, formatting, styles, and structure. Typical use cases include legal contracts, business reports, and any collaborative editing workflow where accurate change tracking matters.

The API:

- Compares **DOC and DOCX** files (and Word-compatible formats such as RTF, ODT, DOT, DOTX).
- Highlights insertions, deletions, and formatting changes.
- Exports the result as a Word document or any other supported format.

## Steps to compare Word documents

1. Create a `Comparer` instance and load the source Word document.
2. Add one or more target Word documents via `add()`.
3. Call `compare()` to generate the result file.

## Example: Compare Word documents

{{< tabs "compare-word">}}
{{< tab "compare_word_documents.py" >}}
```python
from groupdocs.comparison import Comparer

def compare_word_documents():
    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")
        comparer.compare("./result.docx")

if __name__ == "__main__":
    compare_word_documents()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-word-documents/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-word-documents/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/compare-word-documents/compare_word_documents/result.docx)
{{< /tab >}}
{{< /tabs >}}

## Word-specific options

The base flow above works for any Word format, but several options on `CompareOptions` are specifically useful when comparing Word documents:

| Option | Purpose | Topic |
|---|---|---|
| `word_track_changes` | Include or ignore previously-tracked revisions | [Word track changes]({{< ref "comparison/python-net/developer-guide/comparing-documents/word-track-changes" >}}) |
| `compare_bookmarks` | Detect changes inside bookmarked ranges | [Compare bookmarks in Word documents]({{< ref "comparison/python-net/developer-guide/comparing-documents/compare-bookmarks-in-word" >}}) |
| `revision_author_name` | Attribute changes in the result to a specific author | [Setting author of changes]({{< ref "comparison/python-net/developer-guide/comparing-documents/setting-author-of-changes" >}}) |
| `show_revisions` | Show or hide inline revision markers in the result | [Show revisions]({{< ref "comparison/python-net/developer-guide/comparing-documents/show-revisions" >}}) |
| `compare_variable_property` / `compare_document_property` | Compare document metadata | [Compare variables and document properties]({{< ref "comparison/python-net/developer-guide/comparing-documents/compare-of-variables-and-document-properties" >}}) |

## Related topics

- [Accept or reject detected changes]({{< ref "comparison/python-net/developer-guide/comparing-documents/accept-or-reject-detected-changes" >}}) — apply only the changes you want.
- [Accept or reject revisions]({{< ref "comparison/python-net/developer-guide/comparing-documents/accept-or-reject-revisions" >}}) — process Word Track Changes revisions independently of comparison.
- [Customize changes styles]({{< ref "comparison/python-net/developer-guide/comparing-documents/customize-changes-styles" >}}) — change colours and decorations for inserted/deleted/changed items.

---

## Load File from Stream

Path: /comparison/python-net/developer-guide/loading-documents/load-file-from-stream/


To avoid persisting intermediate files, work with file streams directly. Pass an open binary stream to `Comparer` and `add()`.

1. Open the source and target files as binary streams.
2. Pass the source stream to the `Comparer` constructor.
3. Pass the target stream to `add()`.
4. Call `compare()` with the result path or output stream.

## Example: Load files from streams

{{< tabs "load-from-stream">}}
{{< tab "load_file_from_stream.py" >}}
```python
from groupdocs.comparison import Comparer

def load_file_from_stream():
    with open("./source.docx", "rb") as source_stream, \
         open("./target.docx", "rb") as target_stream:
        with Comparer(source_stream) as comparer:
            comparer.add(target_stream)
            comparer.compare("./result.docx")
            print("Documents compared successfully. Check output in result.docx.")

if __name__ == "__main__":
    load_file_from_stream()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/loading-documents/load-file-from-stream/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/loading-documents/load-file-from-stream/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/loading-documents/load-file-from-stream/load_file_from_stream/result.docx)
{{< /tab >}}
{{< /tabs >}}

---

## Set a Password for the Resultant Document

Path: /comparison/python-net/developer-guide/saving-results/set-password-for-resultant-document/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) can apply a password to the comparison result. Combine `CompareOptions.password_save_option = PasswordSaveOption.USER` with `SaveOptions.password = "<your password>"`.

## Example: Password-protect the result document

{{< tabs "set-output-password">}}
{{< tab "set_password_for_resultant_document.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import CompareOptions, SaveOptions, PasswordSaveOption

def set_password_for_resultant_document():
    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")

        compare_options = CompareOptions()
        compare_options.password_save_option = PasswordSaveOption.USER

        save_options = SaveOptions()
        save_options.password = "3333"

        comparer.compare("./result.docx", save_options, compare_options)

if __name__ == "__main__":
    set_password_for_resultant_document()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/saving-results/set-password-for-resultant-document/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/saving-results/set-password-for-resultant-document/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/saving-results/set-password-for-resultant-document/set_password_for_resultant_document/result.docx)
{{< /tab >}}
{{< /tabs >}}

Opening `result.docx` will require the password `3333`.

---

## Supported Document Formats

Path: /comparison/python-net/getting-started/supported-document-formats/


This topic lists file formats supported by [GroupDocs.Comparison](https://products.groupdocs.com/comparison/python-net). You can use the input below to filter supported formats by extension.

{{< table-filter placeholder="Start typing to find file format" forumUrl="https://forum.groupdocs.com/c/comparison/12">}}

## CAD and 3D file formats

| Format | Description | Automatic format detection |
| --- | --- | :---: |
| [DWG](https://docs.fileformat.com/cad/dwg/) | AutoCAD Drawing | ✅ |
| [DXF](https://docs.fileformat.com/cad/dxf/) | Drawing Exchange Format | ✅ |

## EBook file formats

| Format | Description | Automatic format detection |
| --- | --- | :---: |
| [MOBI](https://docs.fileformat.com/ebook/mobi/) | Mobipocket EBook | ✅ |

## Email file formats

| Format | Description | Automatic format detection | 
| --- | --- | :---: | 
| [EML](https://docs.fileformat.com/email/eml/) | Email Message | ✅ |
| [EMLX](https://docs.fileformat.com/email/emlx/) | Apple Mail Message | ✅ |
| [MSG](https://docs.fileformat.com/email/msg/) | Outlook Message Item File | ✅ |

## Image file formats

| Format | Description | Automatic format detection |
| --- | --- | :---: |
| [BMP](https://docs.fileformat.com/image/bmp/) | Bitmap Image | ✅ |
| [DCM](https://docs.fileformat.com/image/dcm/) | DICOM (Digital Imaging and Communications in Medicine) Image | ✅ |
| [DJVU](https://docs.fileformat.com/image/djvu/) | DjVu Image | ✅ |
| [GIF](https://docs.fileformat.com/image/gif/) | Graphical Interchange Format | ✅ |
| [JPEG / JPG](https://docs.fileformat.com/image/jpeg) | JPEG Image | ✅ |
| [PNG](https://docs.fileformat.com/image/png/) | Portable Network Graphics | ✅ |
| [SVG](https://docs.fileformat.com/page-description-language/svg/) | Scalable Vector Graphics File | ✅ |

## Note-taking file formats

| Format | Description | Automatic format detection |
| --- | --- | :---: |
| [ONE](https://docs.fileformat.com/note-taking/one/) | Microsoft OneNote Document | ✅ |

## Page Layout file formats

| Format | Description | Automatic format detection |
| --- | --- | :---: |
| [PDF](https://docs.fileformat.com/pdf/) | Adobe Portable Document Format | ✅ |

## Presentation file formats

| Format | Description | Automatic format detection |
| --- | --- | :---: |
| [ODP](https://docs.fileformat.com/presentation/odp/) | OpenDocument Presentation | ✅ |
| [OTP](https://docs.fileformat.com/presentation/otp/) | OpenDocument Presentation Template | ✅ |
| [POT](https://docs.fileformat.com/presentation/pot/) | Microsoft PowerPoint 97-2003 Template | ✅ |
| [POTX](https://docs.fileformat.com/presentation/potx/) | Microsoft PowerPoint Template | ✅ |
| [PPS](https://docs.fileformat.com/presentation/pps/) | Microsoft PowerPoint 97-2003 Slide Show | ✅ |
| [PPSX](https://docs.fileformat.com/presentation/ppsx/) | Microsoft PowerPoint Slide Show | ✅ |
| [PPT](https://docs.fileformat.com/presentation/ppt/) | Microsoft PowerPoint 97-2003 Presentation | ✅ |
| [PPTX](https://docs.fileformat.com/presentation/pptx/) | Microsoft PowerPoint Presentation | ✅ |

## Spreadsheet file formats

| Format | Description | Automatic format detection |
| --- | --- | :---: |
| [CSV](https://docs.fileformat.com/spreadsheet/csv/) | Comma Separated Values File | ✅ |
| [ODS](https://docs.fileformat.com/spreadsheet/ods/) | OpenDocument Spreadsheet | ✅ |
| [XLS](https://docs.fileformat.com/spreadsheet/xls/) | Microsoft Excel 97-2003 Workbook | ✅ |
| [XLSB](https://docs.fileformat.com/spreadsheet/xlsb/) | Microsoft Excel Binary Workbook | ✅ |
| [XLSM](https://docs.fileformat.com/spreadsheet/xlsm/) | Microsoft Excel Macro-Enabled Workbook | ✅ |
| [XLSX](https://docs.fileformat.com/spreadsheet/xlsx/) | Microsoft Excel Workbook | ✅ |
| [XLT](https://docs.fileformat.com/spreadsheet/xlt/) | Microsoft Excel 97-2003 Template | ✅ |
| [XLTX](https://docs.fileformat.com/spreadsheet/xltx/) | Microsoft Excel Template | ✅ |
| [XLTM](https://docs.fileformat.com/spreadsheet/xltm/) | Microsoft Excel Macro-Enabled Template | ✅ |
| [XML](https://docs.fileformat.com/spreadsheet/) | XML Spreadsheet 2003 | ✅ |

## Text and programming file formats

| Format | Description | Automatic format detection |
| --- | --- | :---: |
| [AS / AS3](https://docs.fileformat.com/programming/as/) | ActionScript File | ✅ |
| [ASM](https://docs.fileformat.com/programming/asm/) | Assembly Language Source Code File | ✅ |
| [BAT](https://docs.fileformat.com/executable/bat/) | DOS Batch File | ✅ |
| [C](https://docs.fileformat.com/programming/c/) | C/C++ Source Code File | ✅ |
| [CC](https://docs.fileformat.com/programming/c/) | C++ Source Code File | ✅ |
| [CMAKE](https://docs.fileformat.com/programming/cmake/) | CMake File | ✅ |
| [CPP](https://docs.fileformat.com/programming/cpp/) | C++ Source Code File | ✅ |
| [CS](https://docs.fileformat.com/specification/programming/cs/) | C# Source Code File | ✅ |
| [CSS](https://docs.fileformat.com/web/css/) | Cascading Style Sheet | ✅ |
| [CXX](https://docs.fileformat.com/programming/cxx/) | C++ Source Code File | ✅ |
| [DIFF](https://docs.fileformat.com/programming/diff/) | Patch File | ✅ |
| [ERB](https://docs.fileformat.com/programming/erb/) | Ruby ERB Script | ✅ |
| [GROOVY](https://docs.fileformat.com/programming/groovy/) | Groovy Source Code File | ✅ |
| [H](https://docs.fileformat.com/programming/h/) | C/C++/Objective-C Header File | ✅ |
| [HAML](https://docs.fileformat.com/programming/haml/) | Haml Source Code File | ✅ |
| [HH](https://docs.fileformat.com/programming/hh/) | C++ Header File | ✅ |
| [JAVA](https://docs.fileformat.com/programming/java/) | Java Source Code File | ✅ |
| [JS](https://docs.fileformat.com/web/js/) | JavaScript File | ✅ |
| [JSON](https://docs.fileformat.com/web/json/) | JavaScript Object Notation File | ✅ |
| [LESS](https://docs.fileformat.com/web/less/) | LESS Style Sheet | ✅ |
| [LOG](https://docs.fileformat.com/database/log/) | Log File | ✅ |
| [M](https://docs.fileformat.com/programming/m/) | Objective-C Implementation File | ✅ |
| [MAKE](https://docs.fileformat.com/programming/make/) | Xcode Makefile Script | ✅ |
| [MD](https://docs.fileformat.com/word-processing/md/) | Markdown Documentation File | ✅ |
| [ML](https://docs.fileformat.com/programming/ml/) | ML Source Code File | ✅ |
| [MM](https://docs.fileformat.com/programming/mm/) | Objective-C++ Source File | ✅ |
| [PHP](https://docs.fileformat.com/programming/php/) | PHP Source Code File | ✅ |
| [PL](https://docs.fileformat.com/programming/pl/) | Perl Script | ✅ |
| [PROPERTIES](https://en.wikipedia.org/wiki/.properties) | Java Properties File | ✅ |
| [PY](https://docs.fileformat.com/programming/py/) | Python Script | ✅ |
| [RB](https://docs.fileformat.com/ebook/rb/) | Ruby Source Code | ✅ |
| [RST](https://docs.fileformat.com/programming/rst/) | reStructuredText File | ✅ |
| [SASS](https://docs.fileformat.com/web/sass/) | Syntactically Awesome StyleSheets File | ✅ |
| [SCALA](https://docs.fileformat.com/programming/scala/) | Scala Source Code File | ✅ |
| [SH](https://docs.fileformat.com/programming/sh/) | Bash Shell Script | ✅ |
| [SQL](https://docs.fileformat.com/database/sql/) | Structured Query Language Data File | ✅ |
| [TXT](https://docs.fileformat.com/word-processing/txt) | Plain Text File | ✅ |
| [VIM](https://docs.fileformat.com/misc/vim/) | Vim Settings File | ✅ |
| [XML](https://docs.fileformat.com/web/xml/) | XML File | ✅ |
| [YAML](https://docs.fileformat.com/programming/yaml/) | YAML Document | ✅ |

## Visio file formats

| Format | Description | Automatic format detection |
| --- | --- | :---: |
| [VDX](https://docs.fileformat.com/image/vdx/) | Visio Drawing XML File | ✅ |
| [VSD](https://docs.fileformat.com/image/vsd/) | Visio 2003-2010 Drawing | ✅ |
| [VSDX](https://docs.fileformat.com/image/vsdx/) | Visio Drawing | ✅ |
| [VSS](https://docs.fileformat.com/image/vss/) | Visio 2003-2010 Stencil | ✅ |
| [VST](https://docs.fileformat.com/image/vst/) | Visio 2003-2010 Template | ✅ |

## Web file formats

| Format | Description | Automatic format detection |
| --- | --- | :---: |
| [HTML](https://docs.fileformat.com/web/html/) | Hypertext Markup Language Format | ✅ |
| [MHT](https://docs.fileformat.com/web/mht/) | MHTML Web Archive | ✅ |
| [MHTML](https://docs.fileformat.com/web/mhtml/) | MIME HTML Format | ✅ |

## Word processing file formats

| Format | Description | Automatic format detection |
| --- | --- | :---: |
| [DOC](https://docs.fileformat.com/word-processing/doc/) | Microsoft Word 97-2003 Document | ✅ |
| [DOCM](https://docs.fileformat.com/word-processing/docm/) | Microsoft Word Macro-Enabled Document | ✅ |
| [DOCX](https://docs.fileformat.com/word-processing/docx/) | Microsoft Word Document | ✅ |
| [DOT](https://docs.fileformat.com/word-processing/dot/) | Microsoft Word 97-2003 Template | ✅ |
| [DOTM](https://docs.fileformat.com/word-processing/dotm/) | Microsoft Word Macro-Enabled Template | ✅ |
| [DOTX](https://docs.fileformat.com/word-processing/dotx/) | Microsoft Word Template | ✅ |
| [ODT](https://docs.fileformat.com/word-processing/odt/) | OpenDocument Text | ✅ |
| [OTT](https://docs.fileformat.com/word-processing/ott/) | OpenDocument Text Template | ✅ |
| [RTF](https://docs.fileformat.com/word-processing/rtf/) | Rich Text Document | ✅ |

---

## Compare PDF Documents

Path: /comparison/python-net/developer-guide/comparing-documents/compare-pdf-documents/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) compares PDF documents and identifies changes in text, formatting, annotations, and structure. Typical use cases include contract review, legal-document comparison, and any workflow where precise difference detection is critical.

The API:

- Compares two or more **PDF files**.
- Highlights insertions, deletions, and formatting changes.
- Saves the comparison result to a new PDF or any other supported format.

## Steps to compare PDF documents

1. Create a `Comparer` instance and load the source PDF file.
2. Add one or more target PDF files via `add()`.
3. Call `compare()` with the result file path.

## Example: Compare PDF documents

{{< tabs "compare-pdf">}}
{{< tab "compare_pdf_documents.py" >}}
```python
from groupdocs.comparison import Comparer

def compare_pdf_documents():
    with Comparer("./source.pdf") as comparer:
        comparer.add("./target.pdf")
        comparer.compare("./result.pdf")

if __name__ == "__main__":
    compare_pdf_documents()
```
{{< /tab >}}
{{< tab "source.pdf" >}}
{{< tab-text >}}
`source.pdf` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-pdf-documents/source.pdf) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.pdf" >}}
{{< tab-text >}}
`target.pdf` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-pdf-documents/target.pdf) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.pdf" >}}  
```text
Binary file (PDF, 279 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/compare-pdf-documents/compare_pdf_documents/result.pdf)
{{< /tab >}}
{{< /tabs >}}

## PDF-specific notes

- **Text vs. images.** By default, PDF comparison detects both text and embedded image changes. For text-only review, disable image comparison — see [Disable image comparison in PDF documents]({{< ref "comparison/python-net/developer-guide/comparing-documents/disable-image-comparison-in-pdf-documents" >}}). Text-only mode is faster and produces less visual noise when the PDFs differ only in scanned figures or watermarks.
- **Annotations and form fields.** GroupDocs.Comparison detects changes in PDF annotation text and form-field values alongside body text.
- **Page-level coordinates.** Set `calculate_coordinates = True` on `CompareOptions` to receive pixel-accurate change locations on each page — useful for overlay UIs. See [Get changes coordinates]({{< ref "comparison/python-net/developer-guide/comparing-documents/get-changes-coordinates" >}}).
- **Password-protected PDFs.** Pass a `LoadOptions` with `password` set — see [Load password-protected documents]({{< ref "comparison/python-net/developer-guide/loading-documents/load-password-protected-documents" >}}).

## Related topics

- [Disable image comparison in PDF documents]({{< ref "comparison/python-net/developer-guide/comparing-documents/disable-image-comparison-in-pdf-documents" >}}) — skip image comparison for faster PDF diffs.
- [Get changes coordinates]({{< ref "comparison/python-net/developer-guide/comparing-documents/get-changes-coordinates" >}}) — pixel coordinates for each detected change.
- [Customize changes styles]({{< ref "comparison/python-net/developer-guide/comparing-documents/customize-changes-styles" >}}) — change highlight colours.
- [Save comparison result in a different format]({{< ref "comparison/python-net/developer-guide/saving-results/save-comparison-result-in-different-format" >}}) — export a PDF diff to DOCX or HTML for review tools that don't render PDF inline.

---

## Load Password-Protected Documents

Path: /comparison/python-net/developer-guide/loading-documents/load-password-protected-documents/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) can compare password-protected documents. Supply the source password through a [`LoadOptions`](https://reference.groupdocs.com/comparison/python-net/groupdocs.comparison.options/loadoptions) instance when constructing the `Comparer`, and the target password through a separate `LoadOptions` when calling `add()`.

## Example: Compare a password-protected source and target

{{< tabs "load-password-protected">}}
{{< tab "load_password_protected_documents.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import LoadOptions

def load_password_protected_documents():
    source_load = LoadOptions()
    source_load.password = "1234"

    target_load = LoadOptions()
    target_load.password = "5678"

    with Comparer("./source_protected.docx", source_load) as comparer:
        comparer.add("./target_protected.docx", target_load)
        comparer.compare("./result.docx")

if __name__ == "__main__":
    load_password_protected_documents()
```
{{< /tab >}}
{{< tab "source_protected.docx" >}}
{{< tab-text >}}
`source_protected.docx` is a password-protected source file. Click [here](/comparison/python-net/_sample_files/developer-guide/loading-documents/load-password-protected-documents/source_protected.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target_protected.docx" >}}
{{< tab-text >}}
`target_protected.docx` is a password-protected target file. Click [here](/comparison/python-net/_sample_files/developer-guide/loading-documents/load-password-protected-documents/target_protected.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 24 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/loading-documents/load-password-protected-documents/load_password_protected_documents/result.docx)
{{< /tab >}}
{{< /tabs >}}

## Related topics

- [Compare multiple password-protected documents]({{< ref "comparison/python-net/developer-guide/comparing-documents/compare-multiple-documents" >}}) — extend the same pattern to several targets.

---

## System Requirements

Path: /comparison/python-net/getting-started/system-requirements/


GroupDocs.Comparison for Python via .NET is a self-contained Python wheel; it does not require a separate .NET installation. The .NET runtime is bundled.

## Supported operating systems

GroupDocs.Comparison runs on 64-bit Windows, Linux, and macOS. Per-platform wheels are published.

### Windows

- Windows 10 (x64)
- Windows 11 (x64)
- Windows Server 2016, 2019, 2022, 2025

### Linux

- Ubuntu 20.04+, Debian 11+, Fedora 36+, CentOS Stream 9+ — any glibc-based distribution that meets the manylinux baseline.
- Native dependencies: `libgdiplus`, `libfontconfig1`, `libicu-dev`, `ttf-mscorefonts-installer` — see [Installation]({{< ref "comparison/python-net/getting-started/installation" >}}).

### macOS

- macOS 12 Monterey or later, on Intel x64 or Apple Silicon (arm64).
- Native dependencies: `mono-libgdiplus` via Homebrew.

## Supported Python versions

GroupDocs.Comparison for Python via .NET supports CPython 3.5 through 3.14. The package is published as platform-specific wheels for each supported Python version.

```bash
python --version    # Should print 3.5.x or higher
```

## Hardware requirements

- **CPU:** any 64-bit x86 (x64) or ARM (arm64) processor.
- **RAM:** at least 1 GB free. Large documents and high-DPI conversions benefit from more.
- **Disk:** the wheel itself is ~150 MB. Allow ample temporary space for the documents being compared.

## Development environments

Any Python IDE or text editor works — VS Code, PyCharm, Cursor, Sublime Text, vim, etc. AI assistants such as Claude Code, Cursor, and GitHub Copilot have first-class support via the bundled `AGENTS.md` and the [MCP server]({{< ref "comparison/python-net/agents-and-llm-integration" >}}).

---

## Compare Multiple Documents

Path: /comparison/python-net/developer-guide/comparing-documents/compare-multiple-documents/


{{< alert style="info" >}}
Multi-target comparison is supported for Microsoft Word documents, Microsoft PowerPoint presentations, and OpenDocument presentations.
{{< /alert >}}

[GroupDocs.Comparison](https://products.groupdocs.com/comparison/python-net) can compare a source document against more than two targets in a single operation. Call `add()` for every target before calling `compare()`.

## Steps to compare multiple documents

1. Instantiate a [`Comparer`](https://reference.groupdocs.com/comparison/python-net/groupdocs.comparison/comparer) with the source document path or stream.
2. Call [`add()`](https://reference.groupdocs.com/comparison/python-net/groupdocs.comparison/comparer/#add) for each target document. Repeat for every target.
3. Call [`compare()`](https://reference.groupdocs.com/comparison/python-net/groupdocs.comparison/comparer/#compare) and specify the result file path or output stream.

## Example 1: Compare several documents from file paths

{{< tabs "compare-multiple-path">}}
{{< tab "compare_multiple_documents.py" >}}
```python
from groupdocs.comparison import Comparer

def compare_multiple_documents():
    with Comparer("./source.docx") as comparer:
        comparer.add("./target1.docx")
        comparer.add("./target2.docx")
        comparer.add("./target3.docx")
        comparer.compare("./result.docx")
        print("Documents compared successfully. Result saved to result.docx.")

if __name__ == "__main__":
    compare_multiple_documents()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-multiple-documents/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target1.docx" >}}
{{< tab-text >}}
`target1.docx` is a target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-multiple-documents/target1.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target2.docx" >}}
{{< tab-text >}}
`target2.docx` is a target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-multiple-documents/target2.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target3.docx" >}}
{{< tab-text >}}
`target3.docx` is a target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-multiple-documents/target3.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/compare-multiple-documents/compare_multiple_documents/result.docx)
{{< /tab >}}
{{< /tabs >}}

The result is as follows:

![](/comparison/python-net/images/compare-multiple-word.png)

## Example 2: Compare several documents from streams

For workflows that don't use the local file system, use streams for both inputs and the result:

{{< tabs "compare-multiple-stream">}}
{{< tab "compare_multiple_documents_stream.py" >}}
```python
from groupdocs.comparison import Comparer

def compare_multiple_documents_stream():
    with open("./source.docx", "rb") as src, \
         open("./target1.docx", "rb") as t1, \
         open("./target2.docx", "rb") as t2, \
         open("./target3.docx", "rb") as t3:
        with Comparer(src) as comparer:
            comparer.add(t1)
            comparer.add(t2)
            comparer.add(t3)
            with open("./result.docx", "wb") as out_stream:
                comparer.compare(out_stream)

if __name__ == "__main__":
    compare_multiple_documents_stream()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-multiple-documents/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target1.docx" >}}
{{< tab-text >}}
`target1.docx` is a target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-multiple-documents/target1.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/compare-multiple-documents/compare_multiple_documents_stream/result.docx)
{{< /tab >}}
{{< /tabs >}}

## Example 3: Compare multiple documents with specific compare settings

Pass a [`CompareOptions`](https://reference.groupdocs.com/comparison/python-net/groupdocs.comparison.options/compareoptions) instance to customize how the comparison is rendered — for example, to highlight inserted items in a specific colour.

{{< tabs "compare-multiple-settings">}}
{{< tab "compare_multiple_documents_settings.py" >}}
```python
from groupdocs.comparison import Comparer, Color
from groupdocs.comparison.options import CompareOptions, StyleSettings


def compare_multiple_documents_settings():
    with Comparer("./source.docx") as comparer:
        comparer.add("./target1.docx")
        comparer.add("./target2.docx")
        comparer.add("./target3.docx")

        options = CompareOptions()
        options.inserted_item_style = StyleSettings()
        options.inserted_item_style.font_color = Color.from_name("yellow")

        comparer.compare("./result.docx", options)

if __name__ == "__main__":
    compare_multiple_documents_settings()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-multiple-documents/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target1.docx" >}}
{{< tab-text >}}
`target1.docx` is a target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-multiple-documents/target1.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/compare-multiple-documents/compare_multiple_documents_settings/result.docx)
{{< /tab >}}
{{< /tabs >}}

## Example 4: Compare multiple password-protected documents

When the source or target documents are password-protected, supply the password through a [`LoadOptions`](https://reference.groupdocs.com/comparison/python-net/groupdocs.comparison.options/loadoptions) object when constructing the `Comparer` and when calling `add()`.

{{< tabs "compare-multiple-protected">}}
{{< tab "compare_multiple_documents_protected.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import LoadOptions

def compare_multiple_documents_protected():
    source_load = LoadOptions()
    source_load.password = "1234"

    with Comparer("./source_protected.docx", source_load) as comparer:
        for target, password in (
            ("./target_protected.docx", "5678"),
            ("./target2_protected.docx", "5678"),
            ("./target3_protected.docx", "5678"),
        ):
            load_opts = LoadOptions()
            load_opts.password = password
            comparer.add(target, load_opts)

        comparer.compare("./result.docx")

if __name__ == "__main__":
    compare_multiple_documents_protected()
```
{{< /tab >}}
{{< tab "source_protected.docx" >}}
{{< tab-text >}}
`source_protected.docx` is a password-protected source file. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-multiple-documents/source_protected.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target_protected.docx" >}}
{{< tab-text >}}
`target_protected.docx` is a password-protected target file. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-multiple-documents/target_protected.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target2_protected.docx" >}}
{{< tab-text >}}
`target2_protected.docx` is a password-protected target file. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-multiple-documents/target2_protected.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target3_protected.docx" >}}
{{< tab-text >}}
`target3_protected.docx` is a password-protected target file. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-multiple-documents/target3_protected.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/compare-multiple-documents/compare_multiple_documents_protected/result.docx)
{{< /tab >}}
{{< /tabs >}}

## Related topics

- [Compare documents]({{< ref "comparison/python-net/developer-guide/comparing-documents/compare-documents" >}}) — single-target comparison.
- [Customize changes styles]({{< ref "comparison/python-net/developer-guide/comparing-documents/customize-changes-styles" >}}) — full control over how changes are rendered.
- [Load password-protected documents]({{< ref "comparison/python-net/developer-guide/loading-documents/load-password-protected-documents" >}}) — single-document password handling.

---

## Install GroupDocs.Comparison for Python via .NET

Path: /comparison/python-net/getting-started/installation/


GroupDocs.Comparison for Python via .NET ships as a self-contained Python wheel on [PyPI](https://pypi.org/project/groupdocs-comparison-net/). The wheel bundles the .NET runtime, so no separate .NET installation is required on Windows. On Linux and macOS, a small set of native dependencies is needed for graphics and font rendering.

## Install from PyPI

The recommended way to install GroupDocs.Comparison is via pip:

```bash
pip install groupdocs-comparison-net
```

To install a specific version:

```bash
pip install groupdocs-comparison-net==26.4.0
```

Verify the installation:

```bash
pip show groupdocs-comparison-net
```

## Install from a downloaded wheel

If you cannot install from PyPI (for example, in an offline environment), download the wheel for your platform from the [GroupDocs releases page](https://releases.groupdocs.com/comparison/python-net/) and install it locally.

Wheels are published for four target platforms:

| Platform | Wheel filename suffix |
|---|---|
| Windows x64 | `-win_amd64.whl` |
| Linux x64 | `-manylinux*_x86_64.whl` |
| macOS Intel | `-macosx_*_x86_64.whl` |
| macOS Apple Silicon | `-macosx_*_arm64.whl` |

After downloading, install with pip:

```bash
pip install ./groupdocs_comparison_net-26.4.0-py3-none-win_amd64.whl
```

Expected output:

```text
Processing ./groupdocs_comparison_net-26.4.0-py3-none-win_amd64.whl
Installing collected packages: groupdocs-comparison-net
Successfully installed groupdocs-comparison-net-26.4.0
```

## Native dependencies (Linux and macOS)

On Windows the wheel is self-contained. On Linux and macOS, install the following before running any examples:

### Ubuntu / Debian

```bash
sudo apt update
sudo apt install -y libgdiplus libfontconfig1 libicu-dev ttf-mscorefonts-installer fontconfig
sudo fc-cache -f
```

`ttf-mscorefonts-installer` accepts the EULA interactively; in CI pipelines, accept it non-interactively with `echo "ttf-mscorefonts-installer msttcorefonts/accepted-mscorefonts-eula select true" | sudo debconf-set-selections` before the install.

### macOS

```bash
brew install mono-libgdiplus
```

If GroupDocs.Comparison fails with `DllNotFoundException: libSkiaSharp` on macOS, the system has a stale copy that conflicts with the bundled version. Rename it so the bundled library takes precedence:

```bash
sudo mv /usr/local/lib/libSkiaSharp.dylib /usr/local/lib/libSkiaSharp.dylib.bak
```

## Verify the installation

After installing, confirm that the package imports cleanly:

```bash
python -c "from groupdocs.comparison import Comparer; print('OK')"
```

If this prints `OK`, you are ready to compare your first document — head to the [Quick start guide]({{< ref "comparison/python-net/getting-started/quick-start-guide" >}}).

---

## Load Custom Fonts

Path: /comparison/python-net/developer-guide/loading-documents/load-custom-fonts/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) can compare documents that use non-standard fonts. Register the custom font directory through a `LoadOptions` instance before opening the documents.

## Example: Connect custom fonts and compare documents

{{< tabs "load-custom-fonts">}}
{{< tab "load_custom_fonts.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import LoadOptions

def load_custom_fonts():
    load_options = LoadOptions()
    load_options.font_directories.append("./fonts/")

    with Comparer("./source.docx", load_options) as comparer:
        comparer.add("./target.docx", load_options)
        comparer.compare("./result.docx")

if __name__ == "__main__":
    load_custom_fonts()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/loading-documents/load-custom-fonts/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/loading-documents/load-custom-fonts/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 11 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/loading-documents/load-custom-fonts/load_custom_fonts/result.docx)
{{< /tab >}}
{{< /tabs >}}

The `./fonts/` directory in the example should contain the `.otf` or `.ttf` files needed to render the document accurately.

---

## AI Agents and LLM Integration

Path: /comparison/python-net/agents-and-llm-integration/


## AI agent and LLM friendly

GroupDocs.Comparison for Python via .NET is designed to work seamlessly with AI agents, LLMs, and automated code generation tools. The library ships machine-readable documentation in multiple formats — including an `AGENTS.md` file inside the pip package itself — so that AI assistants can discover and use the API without manual guidance.

## MCP server

GroupDocs provides an [MCP (Model Context Protocol) server](https://docs.groupdocs.com/mcp) that enables LLMs to query the documentation on demand instead of loading it all at once. This saves tokens and lets your AI assistant fetch only the information it needs for the current task.

To connect your AI tool to the MCP server, add the GroupDocs endpoint to your MCP configuration:

{{< tabs "mcp-setup">}}
{{< tab "Claude Code / Claude Desktop" >}}
```json
// Claude Code:    ~/.claude/settings.json (or project .mcp.json)
// Claude Desktop: ~/Library/Application Support/Claude/claude_desktop_config.json
{
  "mcpServers": {
    "groupdocs-docs": {
      "url": "https://docs.groupdocs.com/mcp"
    }
  }
}
```
{{< /tab >}}
{{< tab "GitHub Copilot" >}}
```json
// .vscode/mcp.json in your project root
{
  "servers": {
    "groupdocs-docs": {
      "url": "https://docs.groupdocs.com/mcp"
    }
  }
}
```
{{< /tab >}}
{{< tab "Cursor" >}}
```json
// .cursor/mcp.json in your project root
{
  "mcpServers": {
    "groupdocs-docs": {
      "url": "https://docs.groupdocs.com/mcp"
    }
  }
}
```
{{< /tab >}}
{{< tab "OpenCode" >}}
```json
// ~/.config/opencode/config.json
{
  "mcpServers": {
    "groupdocs-docs": {
      "url": "https://docs.groupdocs.com/mcp"
    }
  }
}
```
{{< /tab >}}
{{< tab "Generic MCP" >}}
```json
// Any MCP-compatible client
{
  "mcpServers": {
    "groupdocs-docs": {
      "url": "https://docs.groupdocs.com/mcp"
    }
  }
}
```
{{< /tab >}}
{{< /tabs >}}

See [https://docs.groupdocs.com/mcp](https://docs.groupdocs.com/mcp) for full setup instructions and the list of available tools.

## AGENTS.md — built into the package

The `groupdocs-comparison-net` pip package includes an `AGENTS.md` file at `groupdocs/comparison/AGENTS.md`. AI coding assistants that scan installed packages (such as Claude Code, Cursor, GitHub Copilot) can automatically discover the API surface, usage patterns, and troubleshooting tips.

After installing the package, you can find it at:

```bash
pip show -f groupdocs-comparison-net | grep AGENTS
```

## Machine-readable documentation

Every documentation page is available as a plain Markdown file that AI tools can fetch and process directly:

| Resource | URL |
|---|---|
| Full documentation (single file) | `https://docs.groupdocs.com/comparison/python-net/llms-full.txt` |
| Full documentation (all products) | `https://docs.groupdocs.com/llms-full.txt` |
| Individual page (any page) | Append `.md` to the page URL, e.g. `https://docs.groupdocs.com/comparison/python-net.md` |
| Quick start guide | `https://docs.groupdocs.com/comparison/python-net/getting-started/quick-start-guide.md` |

### How to use with AI tools

Point your AI assistant to the full documentation file for comprehensive context:

```
Fetch https://docs.groupdocs.com/comparison/python-net/llms-full.txt and use it
as a reference for GroupDocs.Comparison for Python via .NET API.
```

Or reference individual pages for focused tasks:

```
Read https://docs.groupdocs.com/comparison/python-net/getting-started/quick-start-guide.md
and help me compare two DOCX files in Python and print the detected changes.
```

## Why GroupDocs.Comparison is a good building block for AI document workflows

LLM-driven document workflows constantly need to answer one question: *what changed?* Between two contract revisions, between a model-generated draft and the human-edited version, between a vendor's quote yesterday and today, between a reviewed PDF and the latest export. GroupDocs.Comparison gives an agent a deterministic, format-aware answer instead of a token-by-token diff that confuses headings with paragraphs.

Typical agent-driven tasks:

- **Contract / policy review.** Detect inserted, deleted, and modified clauses between two DOCX or PDF revisions and feed only the changes to the model — far cheaper than re-reading both documents.
- **AI-edit audit.** Compare the document the agent produced against the original to verify (and explain) every change it made.
- **Model-vs-ground-truth evaluation.** Score a model-generated DOCX/PDF against a reference document and surface the diffs that matter (text, style, structure).
- **Change-only summarisation.** Render a result document containing only the changes (`show_only_changed = True`) and pass that to the LLM instead of the full file.
- **Accept/reject pipelines.** Let the agent classify each detected change, then re-emit the document honouring its accept/reject decisions via `apply_changes`.

A minimal end-to-end snippet an agent can lift directly:

```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import CompareOptions, ChangeType

# Step 1: detect changes without writing an output document
with Comparer("revision_a.docx") as comparer:
    comparer.add("revision_b.docx")
    options = CompareOptions()
    options.detect_style_changes = True
    options.calculate_coordinates = True
    comparer.compare(compare_options=options)

    changes = comparer.get_changes()
    for c in changes:
        print(f"[{c.type}] {c.text!r}  at ({c.box.x:.0f}, {c.box.y:.0f})")

    # Step 2: filter — only feed inserts/deletes to the LLM
    material = [c for c in changes
                if c.type in (ChangeType.INSERTED, ChangeType.DELETED)]
```

For end-to-end examples — including [accept-or-reject-detected-changes]({{< ref "comparison/python-net/developer-guide/comparing-documents/accept-or-reject-detected-changes" >}}), [compare-multiple-documents]({{< ref "comparison/python-net/developer-guide/comparing-documents/compare-multiple-documents" >}}), and [get-changes-coordinates]({{< ref "comparison/python-net/developer-guide/comparing-documents/get-changes-coordinates" >}}) — see the [Developer Guide]({{< ref "comparison/python-net/developer-guide" >}}). Every code block on those pages has a runnable counterpart in the [examples repository](https://github.com/groupdocs-comparison/GroupDocs.Comparison-for-Python-via-.NET).

## Pair with GroupDocs.Conversion for cross-format comparison

Comparison expects both inputs in the same family (DOCX vs DOCX, PDF vs PDF, …). When an agent needs to compare across formats — a DOCX draft against an exported PDF, a vendor's PPTX against a converted-to-PDF archive copy — chain [GroupDocs.Conversion for Python via .NET](https://docs.groupdocs.com/conversion/python-net/) first:

1. Use **GroupDocs.Conversion** to normalise both inputs to a common target (PDF or DOCX).
2. Use **GroupDocs.Comparison** to detect changes between the normalised pair.

This lets a single agent handle the long tail of email, CAD, archive, and image inputs without having to special-case every source format.

## AGENTS.md reference

The content below is the same `AGENTS.md` file that ships inside the `groupdocs-comparison-net` package. Copy it into your project as `AGENTS.md` or point your AI assistant to this page.

````markdown
# GroupDocs.Comparison for Python via .NET -- AGENTS.md

> Instructions for AI agents working with this package.

Compare documents and detect text, style, and formatting changes -- Word, PDF, Excel, PowerPoint, ODT, HTML, images, and more. Includes accept/reject workflows and multi-source comparison.

## Install

```bash
pip install groupdocs-comparison-net
```

**Python**: 3.5 - 3.14 | **Platforms**: Windows, Linux, macOS

## Resources

| Resource | URL |
|---|---|
| Documentation | https://docs.groupdocs.com/comparison/python-net/ |
| LLM-optimized docs | https://docs.groupdocs.com/comparison/python-net/llms-full.txt |
| API reference | https://reference.groupdocs.com/comparison/python-net/ |
| Code examples | https://docs.groupdocs.com/comparison/python-net/developer-guide/ |
| Release notes | https://releases.groupdocs.com/comparison/python-net/release-notes/ |
| PyPI | https://pypi.org/project/groupdocs-comparison-net/ |
| Free support forum | https://forum.groupdocs.com/c/comparison/ |
| Temporary license | https://purchase.groupdocs.com/temporary-license |

## MCP Server

If your environment has MCP configured, you can connect your AI tool to the GroupDocs documentation server for on-demand API lookups:

```json
{
  "mcpServers": {
    "groupdocs-docs": {
      "url": "https://docs.groupdocs.com/mcp"
    }
  }
}
```

Works with Claude Code (`~/.claude/settings.json`), Cursor (`.cursor/mcp.json`), VS Code Copilot (`.vscode/mcp.json`), and any MCP-compatible client. If MCP is unavailable, fall back to the LLM-optimized docs URL above and this file -- both are shipped inside the wheel.

## Imports

```python
from groupdocs.comparison import License, Metered, Comparer, ComparerSettings, Document, Color
from groupdocs.comparison.common.exceptions import ComparisonException, DocumentComparisonException
from groupdocs.comparison.interfaces import IDocumentInfo
from groupdocs.comparison.localization import SupportedLocales
from groupdocs.comparison.logging import ConsoleLogger
from groupdocs.comparison.options import (
    ApplyChangeOptions, CompareOptions, GetChangeOptions,
    LoadOptions, SaveOptions, PreviewOptions,
    CalculateCoordinatesModeEnumeration, ChangeType, ComparisonDisplayMode,
    DetalisationLevel, FolderComparisonExtension, ImagesInheritance,
    MetadataType, PaperSize, PasswordSaveOption, PreviewFormats,
    StyleSettings, OriginalSize, DiagramMasterSetting, FileAuthorMetadata,
    IgnoreChangeSensitivitySettings, PagesSetup, PdfCompareOptions,
    PreviewResolution, Size, WordCompareOptions,
    Color,  # re-exported from groupdocs.pydrawing for styling
)
from groupdocs.comparison.result import (
    ChangeInfo, ComparisonAction, FileType,
    PageInfo, Rectangle, StyleChangeInfo,
)
from groupdocs.comparison.words.revision import (
    ApplyRevisionOptions, RevisionAction, RevisionHandler,
    RevisionInfo, RevisionType,
)
```

## Quick Start

```python
from groupdocs.comparison import Comparer

with Comparer("source.docx") as comparer:
    comparer.add("target.docx")
    comparer.compare("result.docx")
```

## Compare with Options

```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import CompareOptions

with Comparer("source.docx") as comparer:
    comparer.add("target.docx")
    options = CompareOptions()
    options.sensitivity_of_comparison = 75
    options.detect_style_changes = True
    options.generate_summary_page = True
    comparer.compare("result.docx", options)
```

**Comparer constructor.** `Comparer(file_path=None, folder_path=None, compare_options=None, load_options=None, settings=None, document=None)` accepts kwargs. Pass a path string positionally, or a stream as `document=...`, or a folder via `folder_path=...`:

```python
from groupdocs.comparison import Comparer, ComparerSettings
from groupdocs.comparison.logging import ConsoleLogger
from groupdocs.comparison.options import LoadOptions

settings = ComparerSettings()
settings.logger = ConsoleLogger()

load = LoadOptions(); load.password = "1234"
with Comparer("protected.docx", load_options=load, settings=settings) as comparer:
    comparer.add("target.docx", load_options=load)
    comparer.compare("result.docx")
```

## Get Detected Changes

```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import ChangeType

with Comparer("source.docx") as comparer:
    comparer.add("target.docx")
    comparer.compare()                       # call with no args before get_changes()
    for change in comparer.get_changes():
        print(f"[{change.type}] {change.text}")

# Filter by change type
with Comparer("source.docx") as comparer:
    comparer.add("target.docx")
    comparer.compare()
    inserted = comparer.get_changes(filter=ChangeType.INSERTED)
```

## Accept / Reject Individual Changes

```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import ApplyChangeOptions
from groupdocs.comparison.result import ComparisonAction

with Comparer("source.docx") as comparer:
    comparer.add("target.docx")
    comparer.compare()
    changes = comparer.get_changes()
    # Reject the first detected change
    changes[0].comparison_action = ComparisonAction.REJECT
    apply_opts = ApplyChangeOptions()
    apply_opts.changes = changes
    comparer.apply_changes("result.docx", apply_opts)
```

## Multi-Source Comparison

```python
from groupdocs.comparison import Comparer

with Comparer("source.docx") as comparer:
    comparer.add("target1.docx")
    comparer.add("target2.docx")
    comparer.add("target3.docx")
    comparer.compare("result.docx")
```

## Customise Change Styling (colours)

`StyleSettings` controls how inserted / deleted / changed regions look in the result document. Colour properties accept anything that looks like a colour — a `Color` struct, an `(r, g, b)` or `(r, g, b, a)` tuple, a packed-ARGB `int`, a `'#RRGGBB'` / `'#AARRGGBB'` string, or a named colour string.

```python
from groupdocs.comparison import Comparer, Color
from groupdocs.comparison.options import CompareOptions, StyleSettings

with Comparer("source.docx") as comparer:
    comparer.add("target.docx")
    options = CompareOptions()
    options.inserted_item_style = StyleSettings()
    options.inserted_item_style.font_color = Color.from_name("firebrick")
    options.deleted_item_style = StyleSettings()
    options.deleted_item_style.font_color = (200, 100, 50)        # RGB tuple
    options.deleted_item_style.highlight_color = "#FFFF00"        # hex string
    options.changed_item_style = StyleSettings()
    options.changed_item_style.font_color = 0xFF0000FF            # packed ARGB
    comparer.compare("result.docx", options)
```

`Color` is also importable from `groupdocs.comparison.options` (next to `StyleSettings`) or directly from `groupdocs.pydrawing`. Case-insensitive named-colour access works too (`Color.red`, `Color.Red`, `Color.RED`, `Color.light_blue`).

## Render Page Previews

`Document.generate_preview(PreviewOptions(...))` produces per-page PNG/JPEG/BMP previews. `PreviewOptions` accepts plain Python callables for the stream factories — no adapter classes needed.

```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import PreviewOptions, PreviewFormats

def create_page_stream(page_number: int):
    # Return a writable stream — .NET writes the rendered page into it.
    return open(f"page-{page_number}.png", "wb")

def release_page_stream(page_number: int):
    # Called after .NET is done with the stream. The stream you returned
    # from create_page_stream is already flushed/closed by .NET.
    pass

with Comparer("source.docx") as comparer:
    preview = PreviewOptions(create_page_stream, release_page_stream)
    preview.preview_format = PreviewFormats.PNG
    preview.page_numbers = [1, 2, 3]
    comparer.source.generate_preview(preview)
```

`PreviewOptions(create_page_stream)` is also valid — pass just the create callback and omit the release one.

## Get Change Coordinates

When `CompareOptions.calculate_coordinates = True`, each `ChangeInfo.box` returns a `Rectangle` with snake_case `.x / .y / .width / .height` accessors (no PascalCase-dict gymnastics):

```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import CompareOptions

with Comparer("source.docx") as comparer:
    comparer.add("target.docx")
    options = CompareOptions()
    options.calculate_coordinates = True
    comparer.compare("result.docx", options)
    for change in comparer.get_changes():
        b = change.box
        print(f"({b.x:.0f}, {b.y:.0f}) {b.width:.0f}x{b.height:.0f} — {change.text!r}")
```

## Password-Protected Documents

```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import LoadOptions, SaveOptions

src_load = LoadOptions(); src_load.password = "1234"
tgt_load = LoadOptions(); tgt_load.password = "5678"
save_opts = SaveOptions(); save_opts.password = "out-secret"

with Comparer("protected_source.docx", load_options=src_load) as comparer:
    comparer.add("protected_target.docx", load_options=tgt_load)
    comparer.compare("result.docx",
                     compare_options=None, save_options=save_opts)
```

## Compare from Stream

```python
import io
from groupdocs.comparison import Comparer

with open("source.docx", "rb") as src, open("target.docx", "rb") as tgt:
    with Comparer(src) as comparer:
        comparer.add(tgt)
        comparer.compare("result.docx")

# Or from in-memory bytes
src_buf = io.BytesIO(source_bytes)
tgt_buf = io.BytesIO(target_bytes)
with Comparer(src_buf) as comparer:
    comparer.add(tgt_buf)
    comparer.compare("result.docx")
```

## Get Document Info

```python
from groupdocs.comparison import Comparer

with Comparer("document.docx") as comparer:
    info = comparer.source.get_document_info()
    print(f"Pages: {info.page_count}, Size: {info.size}")
```

## Command Line

The wheel installs a `groupdocs-comparison` console script (also reachable via `python -m groupdocs.comparison`).

```bash
groupdocs-comparison compare SOURCE TARGET OUTPUT [flags]
groupdocs-comparison info FILE
groupdocs-comparison list-formats
groupdocs-comparison --license PATH ...        # apply a license first
groupdocs-comparison --version
groupdocs-comparison --help
python -m groupdocs.comparison --version       # equivalent module form
```

`compare` flags:

| Flag | Type | Effect |
|---|---|---|
| `--password` | str | Password for protected source/target documents |
| `--output-password` | str | Password applied to the resultant document |
| `--sensitivity` | int (0-100) | Sensitivity of comparison |
| `--detect-style-changes` | flag | Detect bold / italic / colour changes |
| `--mark-changed-content` | flag | Mark changed content in the result |
| `--compare-bookmarks` | flag | Include bookmark comparison |
| `--generate-summary-page` | flag | Append a summary page with statistics |
| `--show-revisions` | flag | Show Word track-changes revisions |

**Exit codes.** `0` success · `2` user error (missing input) · `1` runtime error (.NET exception body printed).

**Limits.** The CLI is a thin shim over the Python API for the common case. Drop into Python for: multi-target compare in one Comparer, in-memory streams (`io.BytesIO`), accept/reject individual changes (`apply_changes`), folder comparison, custom logging or comparer settings, revision handlers.

## Licensing

```python
from groupdocs.comparison import License

# From file
License().set_license("path/to/license.lic")

# From stream
with open("license.lic", "rb") as f:
    License().set_license(f)
```

Or auto-apply: `export GROUPDOCS_LIC_PATH="path/to/license.lic"`

**Evaluation vs licensed.** Without a license the library still runs, but PDF output carries an evaluation watermark stamp and non-PDF targets show an equivalent evaluation mark; there is also a page/document count cap. Set `GROUPDOCS_LIC_PATH` (or call `License().set_license(...)`) and re-run to clear both. A 30-day full license is free: https://purchase.groupdocs.com/temporary-license

## API Reference

### Comparer

| Method | Returns | Description |
|---|---|---|
| `__init__(file_path=None, folder_path=None, compare_options=None, load_options=None, settings=None, document=None)` | | Open a source. Pass path positionally, or `folder_path=` / `document=` (stream) by kwarg |
| `add(file_path=None, compare_options=None, load_options=None, document=None)` | `None` | Register a target for comparison. Call repeatedly for multi-source |
| `compare(file_path=None, stream=None, compare_options=None, save_options=None)` | `Document` | Run the comparison. Call with no args before `get_changes()` to materialise without writing output |
| `get_changes(get_change_options=None, filter=None)` | `list[ChangeInfo]` | Retrieve detected changes after `compare()` |
| `apply_changes(file_path=None, apply_change_options=None, stream=None, save_options=None)` | `None` | Re-emit the result honoring per-change `comparison_action` |
| `compare_directory(file_path=None, compare_options=None)` | `None` | Folder-level compare (set `compare_options.directory_compare = True`) |
| `get_result_string()` | `str` | Result document as text |
| `get_result_document_stream()` | `Stream` | Result document as a stream |
| `dispose()` | `None` | Release native resources (use a `with` block instead when possible) |

Properties: `source: Document`, `targets: list[Document]`, `result: Document`, `source_folder: str`, `target_folder: str`.

### CompareOptions

| Property | Type | Writable |
|---|---|---|
| `paper_size` | `PaperSize` | yes |
| `show_deleted_content` | `bool` | yes |
| `show_inserted_content` | `bool` | yes |
| `generate_summary_page` | `bool` | yes |
| `extended_summary_page` | `bool` | yes |
| `show_only_summary_page` | `bool` | yes |
| `detect_style_changes` | `bool` | yes |
| `mark_nested_content` | `bool` | yes |
| `calculate_coordinates` | `bool` | yes |
| `calculate_coordinates_mode` | `CalculateCoordinatesModeEnumeration` | yes |
| `header_footers_comparison` | `bool` | yes |
| `detalisation_level` | `DetalisationLevel` | yes |
| `mark_changed_content` | `bool` | yes |
| `inserted_item_style` | `StyleSettings` | yes |
| `deleted_item_style` | `StyleSettings` | yes |
| `changed_item_style` | `StyleSettings` | yes |
| `mark_line_breaks` | `bool` | yes |
| `compare_images_pdf` | `bool` | yes |
| `images_inheritance_mode` | `ImagesInheritance` | yes |
| `compare_bookmarks` | `bool` | yes |
| `compare_variable_property` | `bool` | yes |
| `compare_document_property` | `bool` | yes |
| `word_track_changes` | `bool` | yes |
| `show_only_changed` | `bool` | yes |
| `directory_compare` | `bool` | yes |
| `user_master_path` | `str` | yes |
| `folder_comparison_extension` | `FolderComparisonExtension` | yes |
| `revision_author_name` | `str` | yes |
| `sensitivity_of_comparison` | `int` | yes |
| `sensitivity_of_comparison_for_tables` | `int?` | yes |
| `ignore_change_settings` | `IgnoreChangeSensitivitySettings` | yes |
| `words_separator_chars` | `Char[]` | yes |
| `password_save_option` | `PasswordSaveOption` | yes |
| `original_size` | `OriginalSize` | yes |
| `diagram_master_setting` | `DiagramMasterSetting` | yes |
| `show_revisions` | `bool` | yes |
| `leave_gaps` | `bool` | yes |

### LoadOptions

| Property | Type | Writable |
|---|---|---|
| `password` | `str` | yes |
| `font_directories` | `list` | yes |
| `load_text` | `bool` | yes |
| `file_type` | `FileType` | yes |

### SaveOptions

| Property | Type | Writable |
|---|---|---|
| `password` | `str` | yes |

### ApplyChangeOptions

| Property | Type | Writable |
|---|---|---|
| `changes` | `list[ChangeInfo]` | yes |
| `save_original_state` | `bool` | yes |

### ChangeInfo

| Property | Type | Description |
|---|---|---|
| `id` | `int` | Stable identifier for the change |
| `type` | `ChangeType` | INSERTED / DELETED / STYLE_CHANGED / etc. |
| `text` | `str` | Affected text |
| `author` | `str` | Original author (when available) |
| `comparison_action` | `ComparisonAction` | Set to ACCEPT / REJECT before `apply_changes()` |
| `box` | `Rectangle` | Coordinates if `calculate_coordinates=True` was set. Read via `change.box.x / .y / .width / .height` |
| `style_changes` | `list[StyleChangeInfo]` | Per-property style deltas |

## Key Patterns

- **Properties**: use `snake_case` -- auto-mapped to .NET `PascalCase`
- **Context managers**: `with Comparer(...) as x:` ensures resources are released
- **Streams**: pass `open("file", "rb")` or `io.BytesIO(data)` where .NET expects Stream
- **Stream write-back**: `BytesIO` objects are updated after .NET writes to them
- **Enums**: case-insensitive, lazy-loaded (e.g., `FileType.DOCX`)
- **Collections**: `for item in result` and `len(result)` work on .NET collections
- **Apply-changes flow**: `compare()` (no args) → `get_changes()` → set `comparison_action` per change → `apply_changes(out, ApplyChangeOptions(changes=...))`. Calling `compare(out)` with an output path skips the apply-changes step entirely.

## Platform Requirements

| Platform | Requirements |
|---|---|
| Windows | None |
| Linux | `apt install libgdiplus libfontconfig1 ttf-mscorefonts-installer` |
| macOS | `brew install mono-libgdiplus` |

## Troubleshooting

**`"Error occurred while converting document"` when comparing XLSX → XLSX** -- known upstream-side issue in `GroupDocs.Comparison.dll` SaveDocument step (reproduces in pure .NET, not a wrapper bug). DOCX/PDF/TXT/PPTX paths are unaffected. Track upstream for a fix; in the meantime convert to PDF or DOCX target instead.

**`Gdip` type initializer / `libgdiplus` DllNotFoundException on macOS Apple Silicon** -- `GroupDocs.Comparison.dll`'s PDF and image diff paths go through `System.Drawing.Common`, which fails to load `libgdiplus` on mac-arm64 even when the library is installed and individually loadable. DOCX/TXT/HTML/PPTX compares are unaffected. Workarounds: (a) compare to a non-rasterized target format like DOCX or HTML when possible; (b) run the comparison on macOS x64, Linux, or Windows where this code path works. Engine-side fix needed (drop `System.Drawing.Common` in favour of SkiaSharp / Aspose.Drawing, which other GroupDocs products already use cross-platform).

**`System.Drawing.Common is not supported`** -- install libgdiplus: `sudo apt install libgdiplus` (Linux) / `brew install mono-libgdiplus` (macOS)

**`Gdip` type initializer exception** -- outdated libgdiplus: `brew reinstall mono-libgdiplus` (macOS)

**Garbled text / missing fonts** -- install fonts: `sudo apt install ttf-mscorefonts-installer fontconfig && sudo fc-cache -f`

**`DllNotFoundException: libSkiaSharp`** -- stale system copy conflicts with bundled version. Rename it: `sudo mv /usr/local/lib/libSkiaSharp.dylib /usr/local/lib/libSkiaSharp.dylib.bak`

**`DOTNET_SYSTEM_GLOBALIZATION_INVARIANT` errors** -- do NOT set this. Install ICU: `sudo apt install libicu-dev`

**`TypeLoadException`** -- reinstall: `pip install --force-reinstall groupdocs-comparison-net`

**Still stuck?** Post your question at https://forum.groupdocs.com/c/comparison/ -- the development team responds directly.
````

## See also

- [Quick Start Guide]({{< ref "comparison/python-net/getting-started/quick-start-guide" >}}) — your first comparison in five minutes
- [Developer Guide]({{< ref "comparison/python-net/developer-guide" >}}) — runnable examples for every API surface
- [API Reference](https://reference.groupdocs.com/comparison/python-net) — full class and method documentation

---

## Compare Folders

Path: /comparison/python-net/developer-guide/compare-folders/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) can compare two folders, surface which files were added, deleted, or modified, and produce either a `TXT` or `HTML` report.

Steps:

1. Instantiate `CompareOptions`.
2. Set `directory_compare = True`.
3. Optionally set `folder_comparison_extension` to `FolderComparisonExtension.HTML` for an HTML report (the default is TXT).
4. Optionally set `show_only_changed = True` to filter out unchanged items.
5. Create `Comparer` with the source folder path and the `CompareOptions`.
6. Call `add()` with the target folder and the same `CompareOptions`.
7. Call `compare_directory()` with the result file path and the `CompareOptions`.

## Example: Compare two folders

The example below uses the bare folder names `SourceFolder` and `TargetFolder` rather than `./SourceFolder` so that the example-runner can detect them as shared sample directories. In your own code you can use any absolute or relative path — `./source-folder`, `/home/me/projects/src`, etc.

{{< tabs "compare-folders">}}
{{< tab "compare_folders.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import CompareOptions, FolderComparisonExtension

def compare_folders():
    compare_options = CompareOptions()
    compare_options.directory_compare = True
    compare_options.folder_comparison_extension = FolderComparisonExtension.HTML
    compare_options.show_only_changed = True

    with Comparer("SourceFolder", compare_options) as comparer:
        comparer.add("TargetFolder", compare_options)
        comparer.compare_directory("./result.html", compare_options)
        print("Folders compared successfully. Check output in result.html.")

if __name__ == "__main__":
    compare_folders()
```
{{< /tab >}}
{{< tab "result.htmlResult.html" >}}  
```text
<!DOCTYPE html><style>
details {
   padding-left: 20px;
}
details details 
   padding-left: calc(100 % -20px);
}
details summary {
    padding-left: 20px;
    cursor: pointer;
[TRUNCATED]
```
[Download full output](/comparison/python-net/_output_files/developer-guide/compare-folders/compare_folders/result.htmlResult.html)
{{< /tab >}}
{{< /tabs >}}

Replace `./SourceFolder` and `./TargetFolder` with the directories you want to compare.

The following images show the comparison results:

| Result in HTML | Result in TXT |
| --- | --- |
| ![](/comparison/python-net/images/result-comparison-folders-html.png) | ![](/comparison/python-net/images/result-comparison-folders-txt.png) |

---

## Compare Markdown Documents

Path: /comparison/python-net/developer-guide/comparing-documents/compare-markdown-documents/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) compares Markdown documents and highlights differences in content, formatting, and structure. Useful for versioned documentation, README files, and technical writing where precise change detection is needed.

The API can:

- Compare two or more **Markdown (.md) files**.
- Highlight insertions, deletions, and modifications.
- Export results to a single Markdown file or another supported format.

## Example: Compare Markdown documents

{{< tabs "compare-markdown">}}
{{< tab "compare_markdown_documents.py" >}}
```python
from groupdocs.comparison import Comparer

def compare_markdown_documents():
    with Comparer("./source.md") as comparer:
        comparer.add("./target.md")
        comparer.compare("./result.md")

if __name__ == "__main__":
    compare_markdown_documents()
```
{{< /tab >}}
{{< tab "source.md" >}}
{{< tab-text >}}
`source.md` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-markdown-documents/source.md) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.md" >}}
{{< tab-text >}}
`target.md` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-markdown-documents/target.md) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< /tabs >}}

## Markdown-specific notes

- **Extensions.** GroupDocs.Comparison recognises `.md`, `.mkd`, `.mdwn`, `.mdown`, `.markdown`, `.markdn`, `.mdtxt`, and `.mdtext` as Markdown content. The output extension drives the result format — pass `result.md` for a merged Markdown file or `result.html` for a rendered HTML report.
- **Structure-aware comparison.** Heading levels, list nesting, and code-block boundaries are preserved in the merged result so the output stays renderable.
- **Front matter.** YAML / TOML front matter is treated as opaque text content. Changes inside the front matter block are reported the same way as body changes.

## Related topics

- [Compare documents]({{< ref "comparison/python-net/developer-guide/comparing-documents/compare-documents" >}}) — the base two-document flow used here.
- [Save comparison result in a different format]({{< ref "comparison/python-net/developer-guide/saving-results/save-comparison-result-in-different-format" >}}) — render the diff to HTML or PDF.
- [Get list of changes]({{< ref "comparison/python-net/developer-guide/comparing-documents/get-list-of-changes" >}}) — process Markdown diffs programmatically.

---

## Licensing and Subscription

Path: /comparison/python-net/getting-started/licensing-and-subscription/


GroupDocs.Comparison for Python via .NET runs in evaluation mode out of the box. To unlock the full feature set, apply a license at the start of your application.

{{< alert style="info" >}}
General purchase and evaluation policies are documented in the [Purchase Policies and FAQ](https://purchase.groupdocs.com/policies) section.
{{< /alert >}}

## Free trial and temporary license

You can try GroupDocs.Comparison without buying a license. The evaluation build is the same as the licensed build — applying a license simply removes the trial restrictions.

### Evaluation mode limitations

- Only the first two pages of each document are processed.
- Trial badges are stamped on the top of every output page.

### 30-day temporary license

For unrestricted evaluation, request a free 30-day [temporary license](https://purchase.groupdocs.com/temporary-license).

## How to set a license

{{< alert style="info" >}}
The license should be set **once per process**, **before** any other GroupDocs.Comparison class is used. Calling `set_license()` multiple times in the same process is harmless but wasteful — subsequent calls are no-ops.
{{< /alert >}}

### Set license from a file

The example guards the call with an `os.path.exists` check so the script fails loudly when the license file is missing instead of raising an opaque runtime error from the .NET layer.

{{< tabs "set-license-from-file">}}
{{< tab "set_license_from_file.py" >}}
```python
import os
from groupdocs.comparison import License

def set_license_from_file():
    # Absolute path to the license file
    license_path = os.path.abspath("./GroupDocs.Comparison.Python.lic")

    if not os.path.exists(license_path):
        print(f"License file not found: {license_path}")
        print("Place a valid .lic file at that path or set GROUPDOCS_LIC_PATH.")
        return

    # Instantiate License and apply the file
    license = License()
    license.set_license(license_path)
    print(f"License applied from: {license_path}")

if __name__ == "__main__":
    set_license_from_file()
```
{{< /tab >}}
{{< /tabs >}}

### Set license from a stream

Same existence guard — if the `.lic` file isn't there, the script exits cleanly with a human-readable message instead of failing inside the stream-open call.

{{< tabs "set-license-from-stream">}}
{{< tab "set_license_from_stream.py" >}}
```python
import os
from groupdocs.comparison import License

def set_license_from_stream():
    # Absolute path to the license file
    license_path = os.path.abspath("./GroupDocs.Comparison.Python.lic")

    if not os.path.exists(license_path):
        print(f"License file not found: {license_path}")
        print("Place a valid .lic file at that path or set GROUPDOCS_LIC_PATH.")
        return

    # Open the license file as a binary stream and apply it
    with open(license_path, "rb") as license_stream:
        license = License()
        license.set_license(license_stream)
        print(f"License applied from stream: {license_path}")

if __name__ == "__main__":
    set_license_from_stream()
```
{{< /tab >}}
{{< /tabs >}}

### Set license from the GROUPDOCS_LIC_PATH environment variable

For applications that should pick up a license without code changes, set `GROUPDOCS_LIC_PATH` and load it explicitly at startup:

```bash
export GROUPDOCS_LIC_PATH="/path/to/GroupDocs.Comparison.Python.lic"
```

```python
import os
from groupdocs.comparison import License

def apply_license_from_env():
    lic_path = os.environ.get("GROUPDOCS_LIC_PATH")

    if not lic_path:
        print("GROUPDOCS_LIC_PATH is not set — running in evaluation mode.")
        return

    if not os.path.isfile(lic_path):
        print(f"GROUPDOCS_LIC_PATH points at a missing file: {lic_path}")
        return

    License().set_license(lic_path)
    print(f"License applied from: {lic_path}")

if __name__ == "__main__":
    apply_license_from_env()
```

## Metered license

A [metered license](https://reference.groupdocs.com/comparison/python-net/groupdocs.comparison/metered) is an alternative usage-based licensing model: you are billed on the volume of data processed rather than per developer. See the [metered licensing FAQ](https://purchase.groupdocs.com/faqs/licensing/metered) for details.

Replace the placeholder `public_key` and `private_key` values with the credentials issued to you — the example guards against the placeholder values and exits with a message if they haven't been edited:

{{< tabs "set-metered-license">}}
{{< tab "set_metered_license.py" >}}
```python
from groupdocs.comparison import Metered

PLACEHOLDER = "*****"

def set_metered_license():
    # Set your public and private metered keys
    public_key = PLACEHOLDER
    private_key = PLACEHOLDER

    if public_key == PLACEHOLDER or private_key == PLACEHOLDER:
        print("Metered keys must be set before running this example.")
        print("Edit public_key and private_key with the credentials from")
        print("https://purchase.groupdocs.com/ to enable metered licensing.")
        return

    # Instantiate Metered and apply the keys
    metered = Metered()
    metered.set_metered_key(public_key, private_key)

    # Inspect usage so far
    mb_processed = metered.get_consumption_quantity()
    credits_used = metered.get_consumption_credit()
    print(f"MB processed: {mb_processed}")
    print(f"Credits used: {credits_used}")

if __name__ == "__main__":
    set_metered_license()
```
{{< /tab >}}
{{< /tabs >}}

## Pricing

Pricing information for GroupDocs.Comparison subscriptions is available at the [pricing page](https://purchase.groupdocs.com/pricing/comparison/python-net).

---

## Load Text from a String

Path: /comparison/python-net/developer-guide/loading-documents/load-text-from-string/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) can compare values from `str` variables directly — useful when the text never lives on disk (CLI input, REST request bodies, in-memory diffs).

Set [`LoadOptions.load_text`](https://reference.groupdocs.com/comparison/python-net/groupdocs.comparison.options/loadoptions/#properties) to `True` to tell `Comparer` that the first argument is a literal string, not a file path. Read the merged result back via `get_result_string()`.

## Example: Compare two strings

{{< tabs "load-from-string">}}
{{< tab "load_text_from_string.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import LoadOptions

def load_text_from_string():
    load_options = LoadOptions()
    load_options.load_text = True

    with Comparer("source text", load_options) as comparer:
        comparer.add("target text", load_options)
        comparer.compare("./result.docx")
        print("Result string:")
        print(comparer.get_result_string())

if __name__ == "__main__":
    load_text_from_string()
```
{{< /tab >}}
{{< tab "load-text-from-string-outputs.zip" >}}  
```text
result.docx (107 bytes)
result.html (479 bytes)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/loading-documents/load-text-from-string/load_text_from_string/load-text-from-string-outputs.zip)
{{< /tab >}}
{{< /tabs >}}

---

## Compare JSON Documents

Path: /comparison/python-net/developer-guide/comparing-documents/compare-json-documents/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) compares JSON files and detects differences in nested objects, arrays, data types, and structures. This is useful for validating APIs, configurations, and large datasets where accuracy is critical.

The API can:

- Compare two or more **JSON documents**.
- Highlight differences in nested objects, arrays, and values.
- Produce a **visual** HTML report with highlighted differences, or a **textual** merged JSON file with inline diff markers.
- Accept or reject detected changes programmatically.

## Example 1: Compare JSON files

{{< tabs "compare-json-basic">}}
{{< tab "compare_json_documents.py" >}}
```python
from groupdocs.comparison import Comparer

def compare_json_documents():
    with Comparer("./source.json") as comparer:
        comparer.add("./target.json")
        comparer.compare("./result.json")

if __name__ == "__main__":
    compare_json_documents()
```
{{< /tab >}}
{{< tab "source.json" >}}
{{< tab-text >}}
`source.json` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-json-documents/source.json) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.json" >}}
{{< tab-text >}}
`target.json` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-json-documents/target.json) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "compare-json-documents-outputs.zip" >}}  
```text
result.html (635 bytes)
result.json (170 bytes)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/compare-json-documents/compare_json_documents/compare-json-documents-outputs.zip)
{{< /tab >}}
{{< /tabs >}}

The resulting `result.json` contains the combined JSON structure with differences highlighted inline.

## Example 2: Visual comparison (HTML report with summary)

Generate a single HTML report that highlights changes visually — deletions in red, insertions or modifications in blue. Add a summary page that lists every change.

{{< tabs "compare-json-html">}}
{{< tab "compare_json_to_html.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import CompareOptions

def compare_json_to_html():
    options = CompareOptions()
    options.generate_summary_page = True

    with Comparer("./source.json") as comparer:
        comparer.add("./target.json")
        comparer.compare("./result.html", options)

if __name__ == "__main__":
    compare_json_to_html()
```
{{< /tab >}}
{{< tab "source.json" >}}
{{< tab-text >}}
`source.json` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-json-documents/source.json) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.json" >}}
{{< tab-text >}}
`target.json` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-json-documents/target.json) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< /tabs >}}

## Example 3: Textual comparison with style detection

Produce a merged JSON file with inline diff markers; detect style and deletion changes.

{{< tabs "compare-json-textual">}}
{{< tab "compare_json_textual.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import CompareOptions

def compare_json_textual():
    options = CompareOptions()
    options.detect_style_changes = True
    options.show_deleted_content = True

    with Comparer("./source.json") as comparer:
        comparer.add("./target.json")
        comparer.compare("./result.json", options)

if __name__ == "__main__":
    compare_json_textual()
```
{{< /tab >}}
{{< tab "source.json" >}}
{{< tab-text >}}
`source.json` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-json-documents/source.json) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "compare-json-textual-outputs.zip" >}}  
```text
result.html (635 bytes)
result.json (170 bytes)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/compare-json-documents/compare_json_textual/compare-json-textual-outputs.zip)
{{< /tab >}}
{{< /tabs >}}

## When to use each output mode

| Result extension | Output | Best for |
|---|---|---|
| `.json` | Merged JSON with inline diff markers (`[deleted]`, `(inserted)`) | Programmatic diff post-processing |
| `.html` | Single HTML report with deletions in red and insertions in blue | Human review, embedded into a PR-review UI |
| `.md` / `.txt` | Plain-text diff representation | CI log output, ChatOps notifications |

`generate_summary_page = True` appends a high-level change-count summary to any output format. `detect_style_changes = True` ensures structural / type-level changes in JSON (e.g., a string becoming a number) are surfaced explicitly.

## Related topics

- [Accept or reject detected changes]({{< ref "comparison/python-net/developer-guide/comparing-documents/accept-or-reject-detected-changes" >}}) — applies to JSON comparison results as well.
- [Get list of changes]({{< ref "comparison/python-net/developer-guide/comparing-documents/get-list-of-changes" >}}) — read the raw change list to build a custom diff UI.
- [Adjusting comparison sensitivity]({{< ref "comparison/python-net/developer-guide/comparing-documents/adjusting-comparison-sensitivity" >}}) — tune how aggressively small JSON edits are reported.

---

## Generate Document Pages Preview

Path: /comparison/python-net/developer-guide/generate-document-pages-preview/


GroupDocs.Comparison can render thumbnail images of selected pages — useful for review dashboards, file browsers, and any UI that needs a quick visual reference without downloading the full document.

## Example: Render PNG previews of selected pages

{{< tabs "generate-page-previews">}}
{{< tab "generate_document_pages_preview.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import PreviewOptions, PreviewFormats


def create_page_stream(page_number):
    # Return a writable stream — GroupDocs.Comparison writes the rendered page into it.
    return open(f"./page-{page_number}.png", "wb")


def release_page_stream(page_number):
    # The stream returned from create_page_stream has already been flushed and
    # closed by .NET. This hook is for any per-page bookkeeping you want to do.
    pass


def generate_document_pages_preview():
    with Comparer("./source.docx") as comparer:
        preview_options = PreviewOptions(create_page_stream, release_page_stream)
        preview_options.preview_format = PreviewFormats.PNG
        preview_options.page_numbers = [1, 2, 3]
        comparer.source.generate_preview(preview_options)

if __name__ == "__main__":
    generate_document_pages_preview()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the document used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/generate-document-pages-preview/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "page-1.png" >}}  
```text
Binary file (PNG, 163 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/generate-document-pages-preview/generate_document_pages_preview/page-1.png)
{{< /tab >}}
{{< /tabs >}}

You can choose the output format (PNG / JPEG), control resolution, and render only selected pages.

Use case: generate thumbnails for a review dashboard without downloading full documents.

---

## How to Run Examples

Path: /comparison/python-net/getting-started/how-to-run-examples/


The Python examples for GroupDocs.Comparison are hosted on GitHub at [GroupDocs.Comparison-for-Python-via-.NET](https://github.com/groupdocs-comparison/GroupDocs.Comparison-for-Python-via-.NET). Every code snippet on this site has a corresponding runnable script in that repository.

## Run examples from the GitHub repository

Make sure [Python 3.5 or newer](https://python.org/) is installed.

1. Clone the examples repository:

   ```bash
   git clone https://github.com/groupdocs-comparison/GroupDocs.Comparison-for-Python-via-.NET.git
   ```

2. Navigate to the project folder:

   ```bash
   cd GroupDocs.Comparison-for-Python-via-.NET
   ```

3. Install the required Python packages:

   ```bash
   pip install -r Examples/requirements.txt
   ```

4. Run all examples in one pass:

   ```bash
   python Examples/run_all_examples.py
   ```

   `run_all_examples.py` discovers every example script in the `Examples/` tree, executes each one in its own directory, and reports pass/fail counts. It exits with a non-zero status if any example fails.

5. To run a single example, change to its directory and execute it directly:

   ```bash
   cd Examples/developer-guide/comparing-documents/compare-documents
   python compare_documents.py
   ```

## Apply a license before running

By default, examples run in evaluation mode (two-page cap + trial badges). To run them with a license:

```bash
export GROUPDOCS_LIC_PATH=/path/to/GroupDocs.Comparison.Python.lic
python Examples/run_all_examples.py
```

`run_all_examples.py` picks up the `GROUPDOCS_LIC_PATH` environment variable and applies the license before running any example.

## Run in Docker

The repository ships a `Dockerfile` that builds an image with the .NET runtime, native dependencies, and a recent Python pre-installed. To build and run the full example suite in a container:

```bash
docker build -t groupdocs-comparison-examples .
docker run --rm \
    -v /path/to/license:/lic:ro \
    -e GROUPDOCS_LIC_PATH=/lic/GroupDocs.Comparison.Python.lic \
    groupdocs-comparison-examples
```

On Windows with Git Bash, run `export MSYS_NO_PATHCONV=1` before `docker run` to prevent MSYS from mangling the `GROUPDOCS_LIC_PATH` value.

## Contribute

If you would like to add or improve an example, the repository is open source. Fork it, edit the code, and submit a pull request — the GroupDocs team will review the change and merge it if it fits the documentation.

---

## Get Supported File Formats Programmatically

Path: /comparison/python-net/developer-guide/get-supported-file-formats/


If you need the [full list of formats]({{< ref "comparison/python-net/getting-started/supported-document-formats" >}}) at runtime — for example, to validate user input — use the static `FileType.get_supported_file_types()` method.

## Example: List all supported file formats

{{< tabs "get-supported-formats">}}
{{< tab "get_supported_file_formats.py" >}}
```python
from groupdocs.comparison.result import FileType

def get_supported_file_formats():
    supported_file_types = FileType.get_supported_file_types()
    for file_type in sorted(supported_file_types, key=lambda x: x.extension):
        print(file_type)
    print("\nSupported file types retrieved successfully.")

if __name__ == "__main__":
    get_supported_file_formats()
```
{{< /tab >}}
{{< tab "get-supported-file-formats.txt" >}}  
```text
ActionScript Programming Language format (.as)
ActionScript Programming Language format (.as3)
Assembler Programming Language format (.asm)
Type of interpreter that processes shell commands (.bash)
File determines the behavior of interactive shells (.bashrc)
Script file in DOS, OS/2 and Microsoft Windows (.bat)
Configuration file for package control on the server-side (.bowerrc)
C-Based Programming Language format (.c)
CAD file format (.cad)
CSharp cross-platform build automation system format (
[TRUNCATED]
```
[Download full output](/comparison/python-net/_output_files/developer-guide/get-supported-file-formats/get_supported_file_formats/get-supported-file-formats.txt)
{{< /tab >}}
{{< /tabs >}}

---

## Logging and Diagnostics

Path: /comparison/python-net/developer-guide/logging-and-diagnostics/


GroupDocs.Comparison for Python via .NET exposes a small logging API through the `groupdocs.comparison.logging` namespace. Use it to surface diagnostic messages during development, capture logs in production, or wire the library's output into your application's existing logging pipeline.

## Console logger

The simplest option is to attach a `ConsoleLogger` via [`ComparerSettings`](https://reference.groupdocs.com/comparison/python-net/groupdocs.comparison/comparersettings) when constructing a `Comparer`. Comparison-time messages are written to standard output:

{{< tabs "logging-console">}}
{{< tab "logging_console.py" >}}
```python
from groupdocs.comparison import Comparer, ComparerSettings
from groupdocs.comparison.logging import ConsoleLogger

def logging_console():
    settings = ComparerSettings()
    settings.logger = ConsoleLogger()

    with Comparer("./source.docx", settings=settings) as comparer:
        comparer.add("./target.docx")
        comparer.compare("./result.docx")

if __name__ == "__main__":
    logging_console()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/logging-and-diagnostics/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/logging-and-diagnostics/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/logging-and-diagnostics/logging_console/result.docx)
{{< /tab >}}
{{< /tabs >}}

Run the script and you will see GroupDocs.Comparison's progress messages, warnings, and errors printed to the console.

## What `ILogger` exposes

`ConsoleLogger` implements the `ILogger` interface. The interface exposes three method families:

| Method | When it fires |
|---|---|
| `trace(message)` | Verbose progress messages (page-by-page, change-by-change) |
| `warning(message)` | Recoverable issues (missing fonts substituted, format quirks) |
| `error(message)` | Failures that aborted part of the operation |

Each method has `_file(path, message)` and `_string(text, message)` overloads — the first arg identifies which document caused the log line.

{{< alert style="info" >}}
Custom Python subclasses of `ILogger` are not yet auto-wrapped by the wheel as of `26.4.0.postN` — passing a custom logger raises `TypeError: cannot wrap … as ILogger`. Use `ConsoleLogger` and redirect stdout/stderr at the OS level for file capture; a future wheel release will add the callback-adapter wiring for `ILogger` subclasses.
{{< /alert >}}

## Writing logs to a file

For now, capture `ConsoleLogger` output to disk by redirecting the process's stdout / stderr at the OS level:

```bash
python my_comparison.py >> groupdocs-comparison.log 2>&1
```

Rotate the log file with your usual operating-system tooling (`logrotate` on Linux, scheduled archival on Windows). On Windows PowerShell:

```powershell
python my_comparison.py *>> groupdocs-comparison.log
```

## Troubleshooting

If a comparison behaves unexpectedly, enable logging first and re-run the example. The logger will surface load-time warnings (missing fonts, unsupported features in a specific format, malformed XML) that the call-site otherwise swallows.

When opening a support ticket on the [forum](https://forum.groupdocs.com/c/comparison/), include the captured log file alongside the source/target documents and a minimal reproducer — the development team can triage faster with the full diagnostic context.

---

## Accept or Reject Detected Changes

Path: /comparison/python-net/developer-guide/comparing-documents/accept-or-reject-detected-changes/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) lets you programmatically accept or reject individual changes before producing the final result. This enables reviewer-style workflows: get the change list, decide per change, then apply the accepted ones.

## Steps to accept or reject changes

1. Compare two documents using `Comparer.compare()`.
2. Enumerate the changes via `comparer.get_changes()`.
3. For each `ChangeInfo`, set `comparison_action` to `ComparisonAction.ACCEPT` or `ComparisonAction.REJECT`.
4. Call `comparer.apply_changes()` with `ApplyChangeOptions(changes=...)` to produce the merged result.

## Example 1: Accept or reject changes (file paths)

{{< tabs "accept-reject-path">}}
{{< tab "accept_or_reject_changes.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import ApplyChangeOptions
from groupdocs.comparison.result import ComparisonAction

def accept_or_reject_changes():
    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")
        comparer.compare()
        changes = comparer.get_changes()

        # Reject the first change; accept everything else
        if changes:
            changes[0].comparison_action = ComparisonAction.REJECT

        comparer.apply_changes("./result.docx", ApplyChangeOptions(changes=changes))

if __name__ == "__main__":
    accept_or_reject_changes()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/accept-or-reject-detected-changes/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/accept-or-reject-detected-changes/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/accept-or-reject-detected-changes/accept_or_reject_changes/result.docx)
{{< /tab >}}
{{< /tabs >}}

The result is as follows:

|                            Accepted changes                             |                             Rejected changes                            |
| :-----------------------------------------------------------------: | :----------------------------------------------------------------: |
| ![](/comparison/python-net/images/accepted-changes.png) | ![](/comparison/python-net/images/rejected-changes.png) |

## Example 2: Accept or reject changes (streams)

Same operation, but everything runs through streams — useful in services that don't persist intermediate files.

{{< tabs "accept-reject-stream">}}
{{< tab "accept_or_reject_changes_stream.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import ApplyChangeOptions
from groupdocs.comparison.result import ComparisonAction

def accept_or_reject_changes_stream():
    with open("./source.docx", "rb") as source_stream, \
         open("./target.docx", "rb") as target_stream:
        with Comparer(source_stream) as comparer:
            comparer.add(target_stream)
            comparer.compare()
            changes = comparer.get_changes()
            if changes:
                changes[0].comparison_action = ComparisonAction.REJECT
            with open("./result.docx", "wb") as out_stream:
                comparer.apply_changes(out_stream, ApplyChangeOptions(changes=changes))

if __name__ == "__main__":
    accept_or_reject_changes_stream()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/accept-or-reject-detected-changes/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/accept-or-reject-detected-changes/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/accept-or-reject-detected-changes/accept_or_reject_changes_stream/result.docx)
{{< /tab >}}
{{< /tabs >}}

## Related topics

- [Accept or reject revisions]({{< ref "comparison/python-net/developer-guide/comparing-documents/accept-or-reject-revisions" >}}) — same accept/reject pattern, but applied to existing Word Track Changes revisions on a single document rather than to detected changes between two documents.
- [How to merge source code files]({{< ref "comparison/python-net/developer-guide/comparing-documents/how-to-merge-source-code-files" >}}) — applies the accept/reject pattern to source code merges.
- [Get list of changes]({{< ref "comparison/python-net/developer-guide/comparing-documents/get-list-of-changes" >}}) — read the change collection without applying any decisions.

---

## Technical Support

Path: /comparison/python-net/technical-support/


GroupDocs provides unlimited free technical support for all of its products. Support is available to every user, including evaluators, through the [Free Support Forum](https://forum.groupdocs.com/) and the [Paid Support Helpdesk](https://helpdesk.groupdocs.com/).

{{< alert style="info" >}}
GroupDocs does not provide technical support over the phone. Phone support is only available for sales and purchase questions.
{{< /alert >}}

## GroupDocs Free Support Forum

If you need help with GroupDocs.Comparison:

- Make sure you are using the latest version before reporting an issue.
- Search the forum, this documentation, and the [API reference](https://reference.groupdocs.com/comparison/python-net/) — your question may already be answered.
- Post at the [GroupDocs.Comparison Free Support Forum](https://forum.groupdocs.com/c/comparison/). Questions are answered directly by the GroupDocs.Comparison development team.
- Allow for time zone differences when expecting a reply.

## Paid Support Helpdesk

Paid support issues have a higher priority than free support requests. Submit a ticket at the [Paid Support Helpdesk](https://helpdesk.groupdocs.com/) to set a higher priority for your issue.

## Report an issue or feature request

When posting an issue, question, or feature request:

- Include the original document(s) and the minimal Python snippet that reproduces the problem. If you need to attach multiple files, zip them.
- Include the GroupDocs.Comparison version, Python version, and operating system.
- Include the full traceback or error message.
- Report one issue per thread — separate issues belong in separate threads.

Attaching documents to GroupDocs forums is safe — only you and the GroupDocs developers have access to the attached files.

---

## Accept or Reject Revisions

Path: /comparison/python-net/developer-guide/comparing-documents/accept-or-reject-revisions/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) can extract Word track-change revisions from a DOCX file, let you accept or reject each one, and save the updated document.

To process revisions, follow these steps:

1. Instantiate a `RevisionHandler` and provide the source document path or stream.
2. Call `get_revisions()` to retrieve the list of revisions.
3. For each revision, set `action` to `RevisionAction.ACCEPT` or `RevisionAction.REJECT`.
4. Call `apply_revision_changes()` with the result file path and `ApplyRevisionOptions` containing the decisions.

## Example 1: Accept insertions and reject other revisions (file)

{{< tabs "accept-reject-revisions-path">}}
{{< tab "accept_or_reject_revisions.py" >}}
```python
from groupdocs.comparison.words.revision import RevisionHandler, RevisionAction, ApplyRevisionOptions

def accept_or_reject_revisions():
    with RevisionHandler("./Document_with_revision.docx") as revision_handler:
        revisions = revision_handler.get_revisions()
        for revision in revisions:
            if revision.type == "Insertion":
                revision.action = RevisionAction.ACCEPT
            else:
                revision.action = RevisionAction.REJECT

        options = ApplyRevisionOptions()
        options.changes = revisions
        revision_handler.apply_revision_changes("./result.docx", options)

if __name__ == "__main__":
    accept_or_reject_revisions()
```
{{< /tab >}}
{{< tab "Document_with_revision.docx" >}}
{{< tab-text >}}
`Document_with_revision.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/accept-or-reject-revisions/Document_with_revision.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 21 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/accept-or-reject-revisions/accept_or_reject_revisions/result.docx)
{{< /tab >}}
{{< /tabs >}}

## Example 2: Process revisions from a stream

{{< tabs "accept-reject-revisions-stream">}}
{{< tab "accept_or_reject_revisions_stream.py" >}}
```python
from groupdocs.comparison.words.revision import RevisionHandler, RevisionAction, ApplyRevisionOptions

def accept_or_reject_revisions_stream():
    with open("./Document_with_revision.docx", "rb") as source_stream:
        with RevisionHandler(source_stream) as revision_handler:
            revisions = revision_handler.get_revisions()
            for revision in revisions:
                if revision.type == "Insertion":
                    revision.action = RevisionAction.ACCEPT

            options = ApplyRevisionOptions()
            options.changes = revisions
            revision_handler.apply_revision_changes("./result.docx", options)

if __name__ == "__main__":
    accept_or_reject_revisions_stream()
```
{{< /tab >}}
{{< tab "Document_with_revision.docx" >}}
{{< tab-text >}}
`Document_with_revision.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/accept-or-reject-revisions/Document_with_revision.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 21 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/accept-or-reject-revisions/accept_or_reject_revisions_stream/result.docx)
{{< /tab >}}
{{< /tabs >}}

## Example 3: Accept or reject all revisions at once

To apply a single decision to every revision in the document, set `common_handler` on `ApplyRevisionOptions`:

{{< tabs "accept-all-revisions">}}
{{< tab "accept_all_revisions.py" >}}
```python
from groupdocs.comparison.words.revision import RevisionHandler, RevisionAction, ApplyRevisionOptions

def accept_all_revisions():
    with RevisionHandler("./Document_with_revision.docx") as revision_handler:
        options = ApplyRevisionOptions()
        options.common_handler = RevisionAction.ACCEPT
        revision_handler.apply_revision_changes("./result.docx", options)

if __name__ == "__main__":
    accept_all_revisions()
```
{{< /tab >}}
{{< tab "Document_with_revision.docx" >}}
{{< tab-text >}}
`Document_with_revision.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/accept-or-reject-revisions/Document_with_revision.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 21 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/accept-or-reject-revisions/accept_all_revisions/result.docx)
{{< /tab >}}
{{< /tabs >}}

## Result of revision processing

| Source file | Result file |
| --- | --- |
| ![](/comparison/python-net/images/revision-file.png) | ![](/comparison/python-net/images/result-revision-file.png) |

## Related topics

- [Accept or reject detected changes]({{< ref "comparison/python-net/developer-guide/comparing-documents/accept-or-reject-detected-changes" >}}) — accept/reject *between* two documents (this page is about revisions *inside* a single document).
- [Word track changes]({{< ref "comparison/python-net/developer-guide/comparing-documents/word-track-changes" >}}) — control whether comparison emits new revisions in the result.
- [Setting author of changes]({{< ref "comparison/python-net/developer-guide/comparing-documents/setting-author-of-changes" >}}) — attribute new revisions to a specific author.

---

## Adjusting Comparison Sensitivity

Path: /comparison/python-net/developer-guide/comparing-documents/adjusting-comparison-sensitivity/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) supports comparison sensitivity values from **0** (fastest, least detailed) to **100** (slowest, most detailed). The default is **75**.

- **0** — fastest comparison; only fully-disjoint substrings are detected as inserts/deletes.
- **75** — the default. Sub-sequences that have more than 75% of their content inserted or deleted are treated as fully inserted or deleted.
- **100** — slowest comparison; any common sub-sequence is taken into account.

### Worked example

Consider these two strings:

| | |
| --- | --- |
| 1. | `It is our equity poetry` |
| 2. | `Jack is a glad calf` |

They share two common sub-sequences: the word `is` and three space characters. The common sub-sequence is " is " (length 4 including spaces). The inserted sub-sequence is **Jackagladcalf** (length 13). The removed sub-sequence is **Itourequitypoetry** (length 17). The percentage of removed and inserted symbols is `(17 + 13) / (17 + 13 + 4) * 100 = 88%`.

- **`sensitivity_of_comparison = 80`** — 88% > 80%, so the common sub-sequence is discarded. Result: `Jack is a glad calfIt is our equity poetry` (the first string is fully removed, the second fully inserted).
- **`sensitivity_of_comparison = 89`** — 88% < 89%, so the common sub-sequence is kept. Result: `JackIt is aour gladequity calfpoetry`.

## Example 1: Adjust overall sensitivity

Increase sensitivity to detect smaller changes; lower it for faster processing.

{{< tabs "sensitivity-overall">}}
{{< tab "adjust_comparison_sensitivity.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import CompareOptions

def adjust_comparison_sensitivity():
    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")
        options = CompareOptions()
        options.sensitivity_of_comparison = 100
        comparer.compare("./result.docx", options)

if __name__ == "__main__":
    adjust_comparison_sensitivity()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/adjusting-comparison-sensitivity/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/adjusting-comparison-sensitivity/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/adjusting-comparison-sensitivity/adjust_comparison_sensitivity/result.docx)
{{< /tab >}}
{{< /tabs >}}

Use case: maximise accuracy for legal or scientific documents where subtle edits matter.

## Example 2: Adjust sensitivity for tables

Tables can have their own sensitivity value, independent of the overall setting:

{{< tabs "sensitivity-tables">}}
{{< tab "adjust_comparison_sensitivity_tables.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import CompareOptions

def adjust_comparison_sensitivity_tables():
    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")
        options = CompareOptions()
        options.sensitivity_of_comparison = 100
        options.sensitivity_of_comparison_for_tables = 75
        comparer.compare("./result.docx", options)

if __name__ == "__main__":
    adjust_comparison_sensitivity_tables()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/adjusting-comparison-sensitivity/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/adjusting-comparison-sensitivity/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/adjusting-comparison-sensitivity/adjust_comparison_sensitivity_tables/result.docx)
{{< /tab >}}
{{< /tabs >}}

Use case: tune detection granularity in tables while keeping overall sensitivity high.

---

## Customize Changes Styles

Path: /comparison/python-net/developer-guide/comparing-documents/customize-changes-styles/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) lets you customize how inserted, deleted, and changed items are rendered in the result document — highlight colour, font colour, bold, italic, underline, and strikethrough.

To customize change styles:

1. Instantiate a `Comparer` with a source path or stream.
2. Call `add()` with the target.
3. Create a `CompareOptions` instance and configure `inserted_item_style`, `deleted_item_style`, and `changed_item_style` with `StyleSettings`.
4. Call `compare()` with the options and a result path or stream.

## Example 1: Custom change styles (file paths)

{{< tabs "customize-styles-path">}}
{{< tab "customize_changes_styles.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison import Color
from groupdocs.comparison.options import CompareOptions, StyleSettings


def customize_changes_styles():
    options = CompareOptions()

    inserted = StyleSettings()
    inserted.font_color = Color.from_name("green")
    inserted.highlight_color = Color.from_name("red")
    inserted.is_underline = True
    inserted.is_bold = True
    options.inserted_item_style = inserted

    deleted = StyleSettings()
    deleted.font_color = Color.from_name("brown")
    deleted.highlight_color = Color.from_name("azure")
    deleted.is_strikethrough = True
    options.deleted_item_style = deleted

    changed = StyleSettings()
    changed.font_color = Color.from_name("firebrick")
    changed.highlight_color = Color.from_name("crimson")
    changed.is_italic = True
    options.changed_item_style = changed

    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")
        comparer.compare("./result.docx", options)

if __name__ == "__main__":
    customize_changes_styles()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/customize-changes-styles/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/customize-changes-styles/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/customize-changes-styles/customize_changes_styles/result.docx)
{{< /tab >}}
{{< /tabs >}}

Use case: enforce corporate branding for change highlights in contract reviews.

## Example 2: Custom change styles (streams)

The same styling, but operating entirely through streams:

{{< tabs "customize-styles-stream">}}
{{< tab "customize_changes_styles_stream.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison import Color
from groupdocs.comparison.options import CompareOptions, StyleSettings


def customize_changes_styles_stream():
    options = CompareOptions()
    options.inserted_item_style = StyleSettings()
    options.inserted_item_style.font_color = Color.from_name("green")
    options.inserted_item_style.is_underline = True

    options.deleted_item_style = StyleSettings()
    options.deleted_item_style.is_strikethrough = True

    options.changed_item_style = StyleSettings()
    options.changed_item_style.is_italic = True

    with open("./source.docx", "rb") as source_stream, \
         open("./target.docx", "rb") as target_stream, \
         open("./result.docx", "wb") as out_stream:
        with Comparer(source_stream) as comparer:
            comparer.add(target_stream)
            comparer.compare(out_stream, options)

if __name__ == "__main__":
    customize_changes_styles_stream()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/customize-changes-styles/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/customize-changes-styles/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/customize-changes-styles/customize_changes_styles_stream/result.docx)
{{< /tab >}}
{{< /tabs >}}

Use case: process documents fully in memory (no temp files) while keeping brand-compliant styling.

---

## Get List of Changes

Path: /comparison/python-net/developer-guide/comparing-documents/get-list-of-changes/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) populates an internal change list during the comparison. After calling `compare()`, retrieve the changes via `get_changes()`.

## Example 1: Get the list of changes from file paths

{{< tabs "get-changes-path">}}
{{< tab "get_list_of_changes.py" >}}
```python
from groupdocs.comparison import Comparer

def get_list_of_changes():
    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")
        comparer.compare()
        for change in comparer.get_changes():
            print(f"Type: {change.type}, Page: {change.page_info.page_number}, Id: {change.id}, Text: {change.text}")

if __name__ == "__main__":
    get_list_of_changes()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/get-list-of-changes/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/get-list-of-changes/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "get-list-of-changes.txt" >}}  
```text
Type: 2, Page: 1, Id: 0, Text: Cool
Type: 2, Page: 1, Id: 1, Text:  
Type: 3, Page: 1, Id: 2, Text: test 
Type: 2, Page: 1, Id: 3, Text:  signatures
Type: 2, Page: 1, Id: 4, Text: Our 
Type: 2, Page: 1, Id: 5, Text: char[
Type: 2, Page: 1, Id: 6, Text: 255]
Type: 2, Page: 1, Id: 7, Text:  
Type: 3, Page: 1, Id: 8, Text:
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/get-list-of-changes/get_list_of_changes/get-list-of-changes.txt)
{{< /tab >}}
{{< /tabs >}}

Use case: build a custom report UI listing every difference with pagination info.

## Example 2: Get the list of changes from streams

{{< tabs "get-changes-stream">}}
{{< tab "get_list_of_changes_stream.py" >}}
```python
from groupdocs.comparison import Comparer

def get_list_of_changes_stream():
    with open("./source.docx", "rb") as source_stream, \
         open("./target.docx", "rb") as target_stream:
        with Comparer(source_stream) as comparer:
            comparer.add(target_stream)
            comparer.compare()
            for change in comparer.get_changes():
                print(f"Type: {change.type}, Page: {change.page_info.page_number}, Id: {change.id}, Text: {change.text}")

if __name__ == "__main__":
    get_list_of_changes_stream()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/get-list-of-changes/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "get-list-of-changes-stream.txt" >}}  
```text
Type: 2, Page: 1, Id: 0, Text: Cool
Type: 2, Page: 1, Id: 1, Text:  
Type: 3, Page: 1, Id: 2, Text: test 
Type: 2, Page: 1, Id: 3, Text:  signatures
Type: 2, Page: 1, Id: 4, Text: Our 
Type: 2, Page: 1, Id: 5, Text: char[
Type: 2, Page: 1, Id: 6, Text: 255]
Type: 2, Page: 1, Id: 7, Text:  
Type: 3, Page: 1, Id: 8, Text:
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/get-list-of-changes/get_list_of_changes_stream/get-list-of-changes-stream.txt)
{{< /tab >}}
{{< /tabs >}}

Use case: integrate diff extraction into services that operate on file streams.

---

## Get Changes Coordinates

Path: /comparison/python-net/developer-guide/comparing-documents/get-changes-coordinates/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) can compute pixel coordinates for each detected change, letting you overlay highlights on preview images of the source and target documents.

## Example: Get coordinates for detected changes

Enable coordinate calculation, run the comparison, and inspect the `box` on each change:

{{< tabs "get-changes-coordinates">}}
{{< tab "get_changes_coordinates.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import CompareOptions

def get_changes_coordinates():
    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")
        options = CompareOptions()
        options.calculate_coordinates = True
        comparer.compare(options)
        for change in comparer.get_changes():
            print(f"Type: {change.type}, X: {change.box.x}, Y: {change.box.y}, Text: {change.text}")

if __name__ == "__main__":
    get_changes_coordinates()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/get-changes-coordinates/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/get-changes-coordinates/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "get-changes-coordinates.txt" >}}  
```text
Type: 2, X: 488.96243, Y: 223.86372, Text: Cool
Type: 2, X: 560.054, Y: 223.86372, Text:  
Type: 3, X: 389.23828, Y: 285.49686, Text: test 
Type: 2, X: 206.4055, Y: 375.95325, Text:  signatures
Type: 2, X: 119.997, Y: 595.8851, Text: Our 
Type: 2, X: 435.85577, Y: 657.51825, Text: char[
Type: 2, X: 435.85577, Y: 657.51825, Text: 255]
Type: 2, X: 498.0422, Y: 657.51825, Text:  
Type: 3, X: 119.997, Y: 922.6783, Text:
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/get-changes-coordinates/get_changes_coordinates/get-changes-coordinates.txt)
{{< /tab >}}
{{< /tabs >}}

Use case: draw bounding boxes over page previews to visualise change locations.

---

## Get Only Summary Page

Path: /comparison/python-net/developer-guide/comparing-documents/get-only-summary-page/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) can produce a result document that contains only the summary page — useful when you want to share change counts without exposing the underlying document content.

## Example: Get only the summary page

{{< tabs "summary-only">}}
{{< tab "get_only_summary_page.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import CompareOptions

def get_only_summary_page():
    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")
        options = CompareOptions()
        options.show_only_summary_page = True
        comparer.compare("./result.docx", options)

if __name__ == "__main__":
    get_only_summary_page()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/get-only-summary-page/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/get-only-summary-page/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 8 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/get-only-summary-page/get_only_summary_page/result.docx)
{{< /tab >}}
{{< /tabs >}}

Use case: share a concise overview of differences without exposing full document content.

The result is as follows:

![](/comparison/python-net/images/get-only-summary-page.png)

## When to use which summary option

| Option | Result content | Use it when |
|---|---|---|
| `generate_summary_page = True` | Result document body + appended summary page | You want both the diff *and* a high-level overview |
| `show_only_summary_page = True` | Only the summary page, no body | You want a concise overview without exposing full document content |
| `extended_summary_page = True` | Adds per-section statistics to whichever summary mode is active | Reporting to non-technical stakeholders who need the breakdown |

The three flags can be combined — e.g., `show_only_summary_page = True` plus `extended_summary_page = True` produces a summary-only document with the richest statistics.

## Related topics

- [Get extended information on the summary page]({{< ref "comparison/python-net/developer-guide/comparing-documents/get-extended-information-on-the-summary-page" >}}) — richer summary content.
- [Get list of changes]({{< ref "comparison/python-net/developer-guide/comparing-documents/get-list-of-changes" >}}) — programmatic equivalent for building custom summaries.

---

## Get Extended Information on the Summary Page

Path: /comparison/python-net/developer-guide/comparing-documents/get-extended-information-on-the-summary-page/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) can append a summary page with extended statistics to the comparison result, going beyond the basic insert/delete/modify counts.

## Example: Enable extended summary information

{{< tabs "extended-summary">}}
{{< tab "get_extended_summary_information.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import CompareOptions

def get_extended_summary_information():
    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")
        options = CompareOptions()
        options.extended_summary_page = True
        comparer.compare("./result.docx", options)

if __name__ == "__main__":
    get_extended_summary_information()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/get-extended-information-on-the-summary-page/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/get-extended-information-on-the-summary-page/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 26 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/get-extended-information-on-the-summary-page/get_extended_summary_information/result.docx)
{{< /tab >}}
{{< /tabs >}}

Use case: provide management with detailed metrics beyond the standard summary counts.

The result is as follows:

![](/comparison/python-net/images/how-to-get-extended-information-image.png)

## What you get with extended summary

The extended summary expands the default change-count summary with:

- Per-section change counts (header, body, footer, footnotes).
- Style-change counts broken out from content-change counts.
- Document-property diffs (when combined with `compare_document_property = True`).
- Page-by-page change distribution.

## When to use which summary option

| Option | Result content | Use it when |
|---|---|---|
| `generate_summary_page = True` | Result document body + appended summary page | You want both the diff *and* a high-level overview |
| `show_only_summary_page = True` | Only the summary page, no body | You want to share a concise overview without exposing full document content |
| `extended_summary_page = True` | Adds per-section statistics to whichever summary mode is active | You're reporting to non-technical stakeholders who need the breakdown |

## Related topics

- [Get only summary page]({{< ref "comparison/python-net/developer-guide/comparing-documents/get-only-summary-page" >}}) — produce a summary-only result document.
- [Compare variables and document properties]({{< ref "comparison/python-net/developer-guide/comparing-documents/compare-of-variables-and-document-properties" >}}) — surface metadata diffs in the summary.
- [Get list of changes]({{< ref "comparison/python-net/developer-guide/comparing-documents/get-list-of-changes" >}}) — programmatic access to the same data.

---

## Get Comparison Result as a Document Object

Path: /comparison/python-net/developer-guide/comparing-documents/get-result-document-object/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) returns a `Document` object from `Comparer.compare()` that exposes the result file name, detected changes, and the result stream. The object model is compatible with Aspose libraries, so you can pass it into downstream processing pipelines.

## Example: Obtain the result Document object

{{< tabs "result-document">}}
{{< tab "get_result_document_object.py" >}}
```python
from groupdocs.comparison import Comparer

def get_result_document_object():
    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")
        result_document = comparer.compare("./result.docx")
        for change in result_document.changes:
            print(f"Source text: {change.source_text}")
            print(f"Target text: {change.target_text}\n")

if __name__ == "__main__":
    get_result_document_object()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/get-result-document-object/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/get-result-document-object/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/get-result-document-object/get_result_document_object/result.docx)
{{< /tab >}}
{{< /tabs >}}

The result will list source and target text segments for each detected change.

---

## Get Source and Target Text from Files

Path: /comparison/python-net/developer-guide/comparing-documents/get-source-and-target-text-from-files/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) records the source and target text for each detected change. Read `source_text` and `target_text` on each `ChangeInfo` to surface the before/after pair.

## Example 1: Get source and target text (file paths)

{{< tabs "source-target-text-path">}}
{{< tab "get_source_and_target_text.py" >}}
```python
from groupdocs.comparison import Comparer

def get_source_and_target_text():
    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")
        comparer.compare("./result.docx")
        for change in comparer.get_changes():
            print(f"Source text: {change.source_text}")
            print(f"Target text: {change.target_text}\n")

if __name__ == "__main__":
    get_source_and_target_text()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/get-source-and-target-text-from-files/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/get-source-and-target-text-from-files/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/get-source-and-target-text-from-files/get_source_and_target_text/result.docx)
{{< /tab >}}
{{< /tabs >}}

Use case: extract changed text pairs to power side-by-side diff review tools.

## Example 2: Get source and target text (streams)

{{< tabs "source-target-text-stream">}}
{{< tab "get_source_and_target_text_stream.py" >}}
```python
from groupdocs.comparison import Comparer

def get_source_and_target_text_stream():
    with open("./source.docx", "rb") as source_stream, \
         open("./target.docx", "rb") as target_stream:
        with Comparer(source_stream) as comparer:
            comparer.add(target_stream)
            comparer.compare("./result.docx")
            for change in comparer.get_changes():
                print(f"Source text: {change.source_text}")
                print(f"Target text: {change.target_text}\n")

if __name__ == "__main__":
    get_source_and_target_text_stream()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/get-source-and-target-text-from-files/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/get-source-and-target-text-from-files/get_source_and_target_text_stream/result.docx)
{{< /tab >}}
{{< /tabs >}}

Use case: feed structured change text into analytics or translation workflows.

---

## Compare Bookmarks in Word Documents

Path: /comparison/python-net/developer-guide/comparing-documents/compare-bookmarks-in-word/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) supports bookmark comparison in Word documents — enable `compare_bookmarks` on `CompareOptions` to detect differences in bookmarked ranges.

## Example: Enable bookmark comparison

{{< tabs "compare-bookmarks">}}
{{< tab "compare_bookmarks_in_word.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import CompareOptions

def compare_bookmarks_in_word():
    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")
        options = CompareOptions()
        options.compare_bookmarks = True
        comparer.compare("./result.docx", options)

if __name__ == "__main__":
    compare_bookmarks_in_word()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-bookmarks-in-word/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-bookmarks-in-word/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 27 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/compare-bookmarks-in-word/compare_bookmarks_in_word/result.docx)
{{< /tab >}}
{{< /tabs >}}

Use case: validate that critical bookmarked sections (e.g., contract clauses) remain unchanged.

The result is as follows:

![](/comparison/python-net/images/compared-bookmarks.png)

## Notes

- **Word-only.** Bookmark comparison applies only to Microsoft Word documents (`.doc`, `.docx`, `.dot`, `.dotx`). For other formats the option is silently ignored.
- **Interaction with `word_track_changes`.** Bookmark comparison runs alongside revision processing — if a bookmarked range contains tracked changes, both are surfaced in the result.
- **Bookmark *content* vs. bookmark *definitions*.** `compare_bookmarks = True` detects content changes inside bookmarked ranges. Pure bookmark-name renames without content change are not surfaced as content diffs.

## Related topics

- [Compare Word documents]({{< ref "comparison/python-net/developer-guide/comparing-documents/compare-word-documents" >}}) — the base Word-comparison flow.
- [Word track changes]({{< ref "comparison/python-net/developer-guide/comparing-documents/word-track-changes" >}}) — include or ignore tracked revisions.
- [Compare variables and document properties]({{< ref "comparison/python-net/developer-guide/comparing-documents/compare-of-variables-and-document-properties" >}}) — also Word-specific.

---

## Compare Variables and Document Properties

Path: /comparison/python-net/developer-guide/comparing-documents/compare-of-variables-and-document-properties/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) can detect changes in Word document properties — variable, built-in, and custom.

## Example: Compare variable and document properties

{{< tabs "compare-properties">}}
{{< tab "compare_variables_and_document_properties.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import CompareOptions

def compare_variables_and_document_properties():
    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")
        options = CompareOptions()
        options.compare_variable_property = True
        options.compare_document_property = True
        comparer.compare("./result.docx", options)

if __name__ == "__main__":
    compare_variables_and_document_properties()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-of-variables-and-document-properties/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/compare-of-variables-and-document-properties/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 26 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/compare-of-variables-and-document-properties/compare_variables_and_document_properties/result.docx)
{{< /tab >}}
{{< /tabs >}}

Use case: ensure key metadata values remain consistent across document versions.

The result is as follows:

![](/comparison/python-net/images/properties-summary-page.png)

## Property types

Microsoft Word recognises three property surfaces:

| Property type | Examples | CompareOption |
|---|---|---|
| **Built-in properties** | Title, Author, Subject, Created, Last modified | `compare_document_property` |
| **Custom properties** | Any user-defined key/value pair (Department, Project code) | `compare_document_property` |
| **Document variables** | Mail-merge fields, automation variables set via VBA / templating tools | `compare_variable_property` |

`compare_document_property = True` covers built-in AND custom properties. `compare_variable_property = True` specifically targets the document-variables surface — this is most useful when comparing generated documents (mail-merge output, templating engines like Jinja-into-Word) where the variable values are the meaningful diff.

## Related topics

- [Compare Word documents]({{< ref "comparison/python-net/developer-guide/comparing-documents/compare-word-documents" >}}) — the base Word-comparison flow.
- [Compare bookmarks in Word documents]({{< ref "comparison/python-net/developer-guide/comparing-documents/compare-bookmarks-in-word" >}}) — another Word-only metadata-style compare.
- [Get extended information on the summary page]({{< ref "comparison/python-net/developer-guide/comparing-documents/get-extended-information-on-the-summary-page" >}}) — surface property diffs prominently in the summary.

---

## Disable Image Comparison in PDF Documents

Path: /comparison/python-net/developer-guide/comparing-documents/disable-image-comparison-in-pdf-documents/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) can skip image comparison when diffing PDFs — useful when only text changes matter and embedded graphics would otherwise add noise to the result.

## Example: Disable image comparison for PDFs

{{< tabs "disable-image-pdf">}}
{{< tab "disable_image_comparison_in_pdf.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import CompareOptions, ImagesInheritance

def disable_image_comparison_in_pdf():
    with Comparer("./source.pdf") as comparer:
        comparer.add("./target.pdf")
        options = CompareOptions()
        options.compare_images_pdf = False
        options.images_inheritance_mode = ImagesInheritance.TARGET
        comparer.compare("./result.pdf", options)

if __name__ == "__main__":
    disable_image_comparison_in_pdf()
```
{{< /tab >}}
{{< tab "source.pdf" >}}
{{< tab-text >}}
`source.pdf` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/disable-image-comparison-in-pdf-documents/source.pdf) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.pdf" >}}
{{< tab-text >}}
`target.pdf` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/disable-image-comparison-in-pdf-documents/target.pdf) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.pdf" >}}  
```text
Binary file (PDF, 279 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/disable-image-comparison-in-pdf-documents/disable_image_comparison_in_pdf/result.pdf)
{{< /tab >}}
{{< /tabs >}}

Use case: speed up PDF comparisons and avoid noise from embedded graphics.

The result is as follows:

![](/comparison/python-net/images/disable-image-comparison-in-pdf-documents.png)

## When to disable image comparison

Disable image comparison when:

- **You only care about text edits.** Legal redlines, contract markup, and editorial review workflows usually treat embedded figures as visual context, not diff content.
- **The PDFs differ only in cosmetic backgrounds.** Scanned letterheads, watermarks, and stamps inflate the change count without surfacing meaningful differences.
- **You need a faster comparison.** Image diffing is the most expensive part of PDF comparison; skipping it can shave seconds off each comparison and is essential at high throughput.

Keep image comparison enabled when:

- **The PDFs are image-heavy** (scanned forms, technical drawings, presentations exported to PDF) — image diffs are the meaningful content.
- **You need pixel-accurate change overlays** combined with `calculate_coordinates = True`.

## `ImagesInheritance` values

When image comparison is disabled, `images_inheritance_mode` controls which document's images appear in the result PDF:

| Value | Behaviour |
|---|---|
| `ImagesInheritance.SOURCE` | The result PDF inherits images from the source document. |
| `ImagesInheritance.TARGET` | The result PDF inherits images from the target document. Useful when the target is the "newer" version and you want its visual layer. |
| `ImagesInheritance.AVERAGE` | A blended image is generated; appropriate only when the images differ only slightly. |

## Related topics

- [Compare PDF documents]({{< ref "comparison/python-net/developer-guide/comparing-documents/compare-pdf-documents" >}}) — base PDF-comparison flow.
- [Get changes coordinates]({{< ref "comparison/python-net/developer-guide/comparing-documents/get-changes-coordinates" >}}) — when you keep image compare on and want overlay coordinates.

---

## Set Shape Color Independently of Font Color

Path: /comparison/python-net/developer-guide/comparing-documents/set-shape-color-independently-of-font-color/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) lets you colour shapes separately from text. Use `StyleSettings.shape_color` alongside `font_color` to emphasize shape modifications without altering text colour coding.

## Example: Different colours for shapes and fonts

{{< tabs "shape-color-independent">}}
{{< tab "set_shape_color_independently.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison import Color
from groupdocs.comparison.options import CompareOptions, StyleSettings


def set_shape_color_independently():
    options = CompareOptions()
    options.detect_style_changes = True
    options.mark_changed_content = True

    inserted = StyleSettings()
    inserted.font_color = Color.from_name("blue")
    inserted.shape_color = Color.from_name("purple")
    options.inserted_item_style = inserted

    deleted = StyleSettings()
    deleted.font_color = Color.from_name("red")
    deleted.shape_color = Color.from_name("orange")
    options.deleted_item_style = deleted

    changed = StyleSettings()
    changed.font_color = Color.from_name("green")
    changed.shape_color = Color.from_name("lightgreen")
    options.changed_item_style = changed

    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")
        comparer.compare("./result.docx", options)

if __name__ == "__main__":
    set_shape_color_independently()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/set-shape-color-independently-of-font-color/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/set-shape-color-independently-of-font-color/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/set-shape-color-independently-of-font-color/set_shape_color_independently/result.docx)
{{< /tab >}}
{{< /tabs >}}

Use case: emphasize shape modifications (e.g., diagrams) without altering text colour coding.

The result is as follows:

![](/comparison/python-net/images/set-shape-color-independently-of-font-color.png)

## When the distinction matters

`StyleSettings.font_color` controls the colour of *text runs* in the result. `StyleSettings.shape_color` controls the colour of *shape outlines and fills* — text frames, callouts, lines, autoshapes, diagram elements.

In documents that mix prose and diagrams (technical specs, contracts with embedded org charts, marketing decks with infographics), using a single colour for both makes shape changes hard to spot against the text-change highlights. Setting `shape_color` distinct from `font_color` gives you a visually obvious "this shape was modified" signal.

When the source/target only differ in text, set `font_color` only and skip `shape_color` — leaving it at the default keeps shapes visually neutral.

## Related topics

- [Customize changes styles]({{< ref "comparison/python-net/developer-guide/comparing-documents/customize-changes-styles" >}}) — the parent topic covering every `StyleSettings` property.
- [Compare PDF documents]({{< ref "comparison/python-net/developer-guide/comparing-documents/compare-pdf-documents" >}}) — PDFs often have shape content worth styling separately.

---

## Setting the Author of Changes

Path: /comparison/python-net/developer-guide/comparing-documents/setting-author-of-changes/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) lets you set a custom revision-author name on the changes recorded in the result document. Useful for audit trails and to attribute changes to a specific reviewer or automated system.

## Example: Set the revision author name

{{< tabs "set-author">}}
{{< tab "set_author_of_changes.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import CompareOptions

def set_author_of_changes():
    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")
        options = CompareOptions()
        options.show_revisions = True
        options.word_track_changes = True
        options.revision_author_name = "New author"
        comparer.compare("./result.docx", options)

if __name__ == "__main__":
    set_author_of_changes()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/setting-author-of-changes/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/setting-author-of-changes/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 24 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/setting-author-of-changes/set_author_of_changes/result.docx)
{{< /tab >}}
{{< /tabs >}}

The result is as follows:

![Change author](/comparison/python-net/images/set-new-author-of-changes-example.png)

## Dependencies

`revision_author_name` only takes effect when revisions are actually being written into the result document. Both of the following must be true:

- `word_track_changes = True` — the comparison engine emits the diffs as Word Track Changes revisions.
- `show_revisions = True` — the revisions are displayed inline rather than hidden.

If either is `False`, `revision_author_name` is recorded in the underlying revision metadata but won't surface in the rendered output.

## When to use

- **Multi-reviewer pipelines.** Different automated processes can stamp their own author name so downstream reviewers see who (or what) generated each change.
- **Audit trails.** Compliance workflows that need to record an explicit "Comparison performed by" attribution on every diffed document.
- **Anonymising changes.** Strip personal names from automation output (e.g., set `revision_author_name = "Automated Diff"`).

## Related topics

- [Word track changes]({{< ref "comparison/python-net/developer-guide/comparing-documents/word-track-changes" >}}) — the underlying revision-writing mechanism.
- [Show revisions]({{< ref "comparison/python-net/developer-guide/comparing-documents/show-revisions" >}}) — toggle revision visibility in the result.
- [Accept or reject revisions]({{< ref "comparison/python-net/developer-guide/comparing-documents/accept-or-reject-revisions" >}}) — process the stamped revisions afterwards.

---

## How to Merge Source Code Files

Path: /comparison/python-net/developer-guide/comparing-documents/how-to-merge-source-code-files/


GroupDocs.Comparison can merge source code files by exposing each detected change as a `ChangeInfo` and letting you set `comparison_action` to `ComparisonAction.ACCEPT` (apply without highlighting) or `ComparisonAction.REJECT` (discard from the result).

## Steps to apply or reject changes

1. Instantiate `Comparer` with the source document path or stream.
2. Call `add()` with the target document.
3. Call `compare()` to run the comparison.
4. Call `get_changes()` to retrieve the change collection.
5. Set `comparison_action` on each change to `ComparisonAction.ACCEPT` or `ComparisonAction.REJECT`.
6. Call `apply_changes()` with `ApplyChangeOptions(changes=...)` to produce the merged file.

## Example scenario

You need to compare several versions of source code files and selectively accept or discard changes made by different authors.

Before comparison:

![Source file](/comparison/python-net/images/how-to-merge-source-code-file-source.png)
![Target file](/comparison/python-net/images/how-to-merge-source-code-file-target.png)

The differences show two methods in `source.cs`: `AddNumbers` and `Sum`. Without using `comparison_action`, all changes are auto-applied to the output and both methods are removed. With `comparison_action` you can choose which method survives.

## Example: Merge two source code files

{{< tabs "merge-source-code">}}
{{< tab "merge_source_code_files.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import ApplyChangeOptions
from groupdocs.comparison.result import ComparisonAction

def merge_source_code_files():
    with Comparer("./source.cs") as comparer:
        comparer.add("./target.cs")
        comparer.compare("./result.cs")
        changes = comparer.get_changes()

        # Accept the first 10 changes; reject the rest
        for i, change in enumerate(changes):
            change.comparison_action = ComparisonAction.ACCEPT if i < 10 else ComparisonAction.REJECT

        with open("./result.cs", "wb") as result_file:
            comparer.apply_changes(result_file, ApplyChangeOptions(changes=changes))

if __name__ == "__main__":
    merge_source_code_files()
```
{{< /tab >}}
{{< tab "source.cs" >}}
{{< tab-text >}}
`source.cs` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/how-to-merge-source-code-files/source.cs) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.cs" >}}
{{< tab-text >}}
`target.cs` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/how-to-merge-source-code-files/target.cs) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.cs" >}}  
```text
Binary file (CS, 121 bytes)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/how-to-merge-source-code-files/merge_source_code_files/result.cs)
{{< /tab >}}
{{< /tabs >}}

## Result

The merged file marks deleted elements in red, added elements in blue, and modified elements in green. An accompanying HTML file highlights every changed code region.

| Result source code file | Result HTML file |
| --- | --- |
| ![](/comparison/python-net/images/how-to-merge-source-code-file-result-CS.png) | ![](/comparison/python-net/images/how-to-merge-source-code-file-result-HTML.png) |

As shown, only one of the two methods was removed.

---

## Show Gap Lines Instead of Changes

Path: /comparison/python-net/developer-guide/comparing-documents/show-gap-lines/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) can produce redacted-style results in which inserted and deleted content is hidden and replaced with empty gap lines. The layout alignment is preserved so readers can see where changes occurred without seeing the changed text.

## Example: Replace changes with gap lines

{{< tabs "show-gap-lines">}}
{{< tab "show_gap_lines.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import CompareOptions

def show_gap_lines():
    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")
        options = CompareOptions()
        options.show_inserted_content = False
        options.show_deleted_content = False
        options.leave_gaps = True
        comparer.compare("./result.docx", options)

if __name__ == "__main__":
    show_gap_lines()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/show-gap-lines/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/show-gap-lines/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/show-gap-lines/show_gap_lines/result.docx)
{{< /tab >}}
{{< /tabs >}}

Use case: provide redacted-style diffs that keep layout alignment without showing actual changed text.

The result is as follows:

|                        Default result                         |                Result without LeaveGaps                       |
| :-----------------------------------------------------------: | :------------------------------------------------------------: |
| ![](/comparison/python-net/images/show-gap-lines-default-result.png) | ![](/comparison/python-net/images/show-gap-lines-without-leavegaps.png) |

|                        Default result                         |                Result with LeaveGaps                          |
| :-----------------------------------------------------------: | :-----------------------------------------------------------: |
| ![](/comparison/python-net/images/show-gap-lines-default-result.png) | ![](/comparison/python-net/images/show-gap-lines-with-leavegaps.png) |

## When to use gap lines

Gap-line output is useful in two scenarios:

- **Redacted-style diffs for regulatory review.** Reviewers can see *where* changes occurred and *how many* without seeing the actual content — useful when the comparison artifact will be circulated more widely than the underlying documents.
- **Visual change density reporting.** A gap-line result document gives a quick visual sense of how much was changed and where, without the cognitive load of reading every diff.

For full-content review use the default settings (`show_inserted_content = True`, `show_deleted_content = True`, `leave_gaps = False`).

## Related topics

- [Show revisions]({{< ref "comparison/python-net/developer-guide/comparing-documents/show-revisions" >}}) — another way to produce a "clean" result by hiding revision markers.
- [Customize changes styles]({{< ref "comparison/python-net/developer-guide/comparing-documents/customize-changes-styles" >}}) — full control over how visible changes look.
- [Get only summary page]({{< ref "comparison/python-net/developer-guide/comparing-documents/get-only-summary-page" >}}) — the most extreme form of redacted output: counts only, no content at all.

---

## Show Revisions

Path: /comparison/python-net/developer-guide/comparing-documents/show-revisions/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) lets you toggle the visibility of inline revision markers in the result. Disable them when you want a clean deliverable for end users.

## Example: Hide revisions in the result

{{< tabs "show-revisions">}}
{{< tab "hide_revisions.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import CompareOptions

def hide_revisions():
    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")
        options = CompareOptions()
        options.show_revisions = False
        comparer.compare("./result.docx", options)

if __name__ == "__main__":
    hide_revisions()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/show-revisions/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/show-revisions/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/show-revisions/hide_revisions/result.docx)
{{< /tab >}}
{{< /tabs >}}

Use case: produce a clean deliverable without inline revision markers for end users.

The result is as follows:

|              Disabled revisions display              |
| :--------------------------------------------------: |
| ![](/comparison/python-net/images/show-revisions-false.png) |

## Interaction with other options

- **`word_track_changes`** — when set to `True`, GroupDocs writes diffs as Word Track Changes revisions. `show_revisions = False` then hides those revision markers in the rendered output but keeps them in the underlying document XML — opening the result in Word with track-changes UI enabled will still show them.
- **`revision_author_name`** — only meaningful when `show_revisions = True`. With revisions hidden, the author name is recorded but invisible.
- **`leave_gaps`** — orthogonal: gap lines apply to inserted/deleted content blocks, not to revision markers.

## Related topics

- [Word track changes]({{< ref "comparison/python-net/developer-guide/comparing-documents/word-track-changes" >}}) — control whether revisions are emitted in the first place.
- [Setting author of changes]({{< ref "comparison/python-net/developer-guide/comparing-documents/setting-author-of-changes" >}}) — attribute revisions to a specific author.
- [Accept or reject revisions]({{< ref "comparison/python-net/developer-guide/comparing-documents/accept-or-reject-revisions" >}}) — process the revisions programmatically after comparison.

---

## Specify File Type for Comparison Manually

Path: /comparison/python-net/developer-guide/comparing-documents/specify-file-type-manually/


[GroupDocs.Comparison for Python via .NET](https://products.groupdocs.com/comparison/python-net) detects file type from the extension by default. When the extension is missing, wrong, or ambiguous, set the file type explicitly via `LoadOptions.file_type`.

## Example: Specify the file type manually

{{< tabs "specify-file-type">}}
{{< tab "specify_file_type_manually.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import LoadOptions
from groupdocs.comparison.result import FileType

def specify_file_type_manually():
    load_options = LoadOptions()
    load_options.file_type = FileType.DOCX

    with Comparer("./source.docx", load_options) as comparer:
        comparer.add("./target.docx", load_options)
        comparer.compare("./result.docx")

if __name__ == "__main__":
    specify_file_type_manually()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/specify-file-type-manually/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/specify-file-type-manually/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/specify-file-type-manually/specify_file_type_manually/result.docx)
{{< /tab >}}
{{< /tabs >}}

Use case: process files with incorrect or missing extensions by forcing the correct type.

## Common `FileType` values

A few commonly-used members of [`groupdocs.comparison.result.FileType`](https://reference.groupdocs.com/comparison/python-net/groupdocs.comparison.result/filetype/):

| Format family | FileType value |
|---|---|
| Word | `FileType.DOCX`, `FileType.DOC`, `FileType.DOT`, `FileType.DOTX`, `FileType.ODT`, `FileType.RTF` |
| PDF | `FileType.PDF` |
| Spreadsheet | `FileType.XLSX`, `FileType.XLS`, `FileType.ODS`, `FileType.CSV` |
| Presentation | `FileType.PPTX`, `FileType.PPT`, `FileType.ODP` |
| Email | `FileType.EML`, `FileType.MSG`, `FileType.EMLX` |
| Image | `FileType.PNG`, `FileType.JPG`, `FileType.BMP`, `FileType.TIFF`, `FileType.GIF` |
| Web | `FileType.HTML`, `FileType.MHTML` |
| Markdown | `FileType.MD`, `FileType.MARKDOWN` |
| Text & code | `FileType.TXT`, `FileType.JSON`, `FileType.XML`, `FileType.YAML`, `FileType.PY`, `FileType.JS`, `FileType.CS`, ... |

To enumerate every supported value at runtime, call [`FileType.get_supported_file_types()`]({{< ref "comparison/python-net/developer-guide/get-supported-file-formats" >}}).

## When to use

- **Files with no extension.** Documents downloaded from S3 or content systems that strip extensions still need a file-type hint.
- **Wrong extension.** Files renamed by content-management systems (e.g., `.bin`, `.dat`) that hold valid Word / PDF bytes.
- **Custom content-type detection.** Pipelines where Python has already inspected the file (via `python-magic` or similar) and wants to bypass the library's extension-based detection.

## Related topics

- [Get supported file formats]({{< ref "comparison/python-net/developer-guide/get-supported-file-formats" >}}) — enumerate every recognised type at runtime.
- [Load file from stream]({{< ref "comparison/python-net/developer-guide/loading-documents/load-file-from-stream" >}}) — streams have no implicit extension; combine with manual file-type for full control.

---

## Save Comparison Result in a Different Format

Path: /comparison/python-net/developer-guide/saving-results/save-comparison-result-in-different-format/


The simplest way to control the output format of a comparison is to pick a result file path with the matching extension. GroupDocs.Comparison infers the output format from the extension and produces a result file in that format.

## Example: Export a DOCX vs DOCX diff to PDF

{{< tabs "save-different-format">}}
{{< tab "save_comparison_result_in_different_format.py" >}}
```python
from groupdocs.comparison import Comparer

def save_comparison_result_in_different_format():
    with Comparer("./source.docx") as comparer:
        comparer.add("./target.docx")
        # Output is inferred from the file extension — .pdf in this case.
        comparer.compare("./result.pdf")

if __name__ == "__main__":
    save_comparison_result_in_different_format()
```
{{< /tab >}}
{{< tab "source.docx" >}}
{{< tab-text >}}
`source.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/saving-results/save-comparison-result-in-different-format/source.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/saving-results/save-comparison-result-in-different-format/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.pdf" >}}  
```text
Binary file (PDF, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/saving-results/save-comparison-result-in-different-format/save_comparison_result_in_different_format/result.pdf)
{{< /tab >}}
{{< /tabs >}}

Supported output formats depend on the source file type. Common targets include DOCX, PDF, and HTML.

Use case: deliver a PDF diff to stakeholders while keeping DOCX for editing.

---

## Word Track Changes

Path: /comparison/python-net/developer-guide/comparing-documents/word-track-changes/


By default, GroupDocs.Comparison includes Microsoft Word Track Changes (revisions) during comparison. Use `CompareOptions.word_track_changes` to toggle that behaviour.

## Example 1: Include Word revisions during comparison

Detect and include tracked revisions (changes, comments, insertions, deletions) from the source document so that any previously tracked changes are preserved in the comparison output.

{{< tabs "track-changes-include">}}
{{< tab "include_word_track_changes.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import CompareOptions

def include_word_track_changes():
    with Comparer("./source-with-revisions.docx") as comparer:
        comparer.add("./target.docx")
        options = CompareOptions()
        options.word_track_changes = True
        comparer.compare("./result.docx", options)

if __name__ == "__main__":
    include_word_track_changes()
```
{{< /tab >}}
{{< tab "source-with-revisions.docx" >}}
{{< tab-text >}}
`source-with-revisions.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/word-track-changes/source-with-revisions.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/word-track-changes/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 25 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/word-track-changes/include_word_track_changes/result.docx)
{{< /tab >}}
{{< /tabs >}}

## Example 2: Ignore Word revisions during comparison

Compare only the final text and ignore previously tracked revisions so historical edits do not affect the diff.

{{< tabs "track-changes-ignore">}}
{{< tab "ignore_word_track_changes.py" >}}
```python
from groupdocs.comparison import Comparer
from groupdocs.comparison.options import CompareOptions

def ignore_word_track_changes():
    with Comparer("./source-with-revisions.docx") as comparer:
        comparer.add("./target.docx")
        options = CompareOptions()
        options.word_track_changes = False
        comparer.compare("./result.docx", options)

if __name__ == "__main__":
    ignore_word_track_changes()
```
{{< /tab >}}
{{< tab "source-with-revisions.docx" >}}
{{< tab-text >}}
`source-with-revisions.docx` is the source file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/word-track-changes/source-with-revisions.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "target.docx" >}}
{{< tab-text >}}
`target.docx` is the target file used in this example. Click [here](/comparison/python-net/_sample_files/developer-guide/comparing-documents/word-track-changes/target.docx) to download it.
{{< /tab-text >}}
{{< /tab >}}
{{< tab "result.docx" >}}  
```text
Binary file (DOCX, 30 KB)
```
[Download full output](/comparison/python-net/_output_files/developer-guide/comparing-documents/word-track-changes/ignore_word_track_changes/result.docx)
{{< /tab >}}
{{< /tabs >}}

Use case: produce a clean diff focused on current content for executive review.

Note: the availability of particular options can depend on the document format and library version.

The result is as follows:

|                     word_track_changes = True                  |
| :------------------------------------------------------------: |
| ![](/comparison/python-net/images/word-track-changes-option-true.png) |

|                     word_track_changes = False                 |
| :-------------------------------------------------------------: |
| ![](/comparison/python-net/images/word-track-changes-option-false.png) |