rtfparse: RTF Parser

0.9.5 · active · verified Wed Apr 15

rtfparse is a Python library for parsing Microsoft Rich Text Format (RTF) documents. It constructs an in-memory object representing the RTF document's tree structure. The library currently provides a renderer (HTML_Decapsulator) to extract encapsulated HTML, particularly useful for processing HTML-formatted emails from Microsoft Outlook, which often use RTF compression. It aims to support custom renderers for diverse RTF processing needs. The library is actively maintained, with version 0.9.5 focusing on bug fixes and documentation, and future plans for version 1.x to include image embedding.

Warnings

gotcha The first execution of the `rtfparse` executable (CLI) will trigger a configuration wizard. This wizard creates a `.rtfparse` folder in the user's home directory to store configuration files and logs. This automatic setup might be unexpected for some users.
Fix: Users can press 'A' for automatic configuration during the first run or manually configure settings if preferred. For programmatic use, this initial setup does not directly interfere with script execution, but logs might still be generated.
gotcha The `HTML_Decapsulator` primarily extracts raw HTML embedded within the RTF structure. It does not fully re-apply RTF-specific styles (like bolding, font size, or specific fonts) during the conversion to plain HTML. This can result in a loss of some visual formatting in the output HTML compared to the original RTF document's appearance.
Fix: For precise styling, manual CSS application or a more advanced RTF-to-HTML conversion library capable of interpreting and translating RTF formatting directives might be necessary. This library is focused on 'decapsulating' existing HTML rather than a full RTF rendering to HTML.
gotcha The `--embed-img` option for the `rtfparse` command-line interface, intended for embedding images into decapsulated HTML, is currently non-functional in all 0.x.x versions. This feature is planned for implementation in `rtfparse` version 1.x.
Fix: Users needing to embed images should await the 1.x release or implement custom logic to handle image embedding after HTML extraction.
gotcha When providing file paths to `Rtf_Parser`, incorrect or non-existent paths will lead to a `FileNotFoundError`. This is a common pitfall, especially when dealing with dynamic paths or different operating system conventions.
Fix: Always ensure that the `rtf_path` provided to `Rtf_Parser` is a valid and accessible `pathlib.Path` object pointing to an existing RTF file. Use `pathlib.Path.exists()` for verification or implement robust error handling.
gotcha RTF documents can contain complex elements (e.g., text boxes, columns, embedded images, headers/footers, nested tables) that are challenging to convert accurately to HTML. When parsing such complex RTF files, the resulting HTML might suffer from significant formatting errors, elements disappearing, or layout issues due to the inherent 'sensitivity' of RTF-to-HTML conversion.
Fix: Simplify RTF documents where possible, especially if the primary goal is HTML conversion. Be aware that precise replication of all RTF formatting in HTML is often difficult across different parsing and rendering engines.

Install

pip install rtfparse Install stable version

Imports

Rtf_Parser
```
from rtfparse.parser import Rtf_Parser
```

De_encapsulate_HTML

from rtfparse.renderers.de_encapsulate_html import De_encapsulate_HTML

Quickstart

This quickstart demonstrates how to programmatically parse an RTF string (written to a temporary file for demonstration) and then use the `De_encapsulate_HTML` renderer to extract any embedded HTML content, saving it to another temporary file. The extracted HTML is then printed to the console.

import pathlib
from rtfparse.parser import Rtf_Parser
from rtfparse.renderers.de_encapsulate_html import De_encapsulate_HTML
import os
import tempfile

# Create a dummy RTF file for demonstration
# In a real scenario, you would read an existing RTF file.
rtf_content = r"{\rtf1\ansi\deff0 This is some {\b bold} text and a line break.\par This is a new line.}"
temp_rtf_file = pathlib.Path(tempfile.gettempdir()) / "dummy_example.rtf"
temp_html_file = pathlib.Path(tempfile.gettempdir()) / "extracted_example.html"

try:
    # Write dummy RTF content to a temporary file
    with open(temp_rtf_file, "w", encoding="ascii") as f:
        f.write(rtf_content)

    print(f"Created temporary RTF file: {temp_rtf_file}")

    # Programmatic usage: Parse the RTF file
    parser = Rtf_Parser(rtf_path=temp_rtf_file)
    parsed_document = parser.parse_file()

    # Render the parsed RTF to extract HTML content
    renderer = De_encapsulate_HTML()
    with open(temp_html_file, mode="w", encoding="utf-8") as html_file:
        renderer.render(parsed_document, html_file)

    print(f"RTF parsed and HTML extracted to: {temp_html_file}")

    # Display the extracted HTML content
    with open(temp_html_file, "r", encoding="utf-8") as f:
        print("\nExtracted HTML content:")
        print(f.read())

except Exception as e:
    print(f"An error occurred: {e}")
finally:
    # Clean up temporary files
    if temp_rtf_file.exists():
        os.remove(temp_rtf_file)
        print(f"Cleaned up {temp_rtf_file}")
    if temp_html_file.exists():
        os.remove(temp_html_file)
        print(f"Cleaned up {temp_html_file}")

view raw JSON →