Replace the text from pdf saving the structure of the document

[NikitaIVll]

Good day,

I am attempting to use PyMuPDF to translate PDF files while preserving the formatting and structure of the document. Could you please provide an example of how I can extract text and replace it with the translated text?

Thank you.

[JorjMcKie]

I cannot give you complete code for this.

But the standard way (and extremely popular among our users) for replacing text are redaction annotations. Do a search in the documentation using "redaction".

The approach should be as follows:

• Extract current text. If you want to know the font and other text properties, you will need the "dict" extraction option.
• Translate it.
• Remove old text using using redactions. This needs the the text coordinates (bbox).
• Insert new text using a suitable font. The font from the old text (embedded in the PDF) is not usable!
• Because new text will not fit in the same rectangle as the old one, you will have to find some way around this. Probably the best solution to start with is inserting translated text via insert_htmlbox and let PyMuPDF automatically find a suitable font for the new language. This also solves the space problem.

Depending on results of this experiment, you can decide how and where to optimize the result.

[NikitaIVll]

@JorjMcKie
Thank you for your advice. That's what I've been able to achieve using your strategy.
However, I still don't understand how to format the text, meaning saving the text color, bold font, italics, etc.
Also not sure if I'm using ```
page.add_redact_annot(rect, text="")
page.apply_reductions()

in the right place
I will be glad of your advice!
Thanks

import fitz  # PyMuPDF
from googletrans import Translator

def extract_text_blocks(pdf_path):
    doc = fitz.open(pdf_path)
    pages_blocks = []
    for page_num in range(len(doc)):
        page = doc.load_page(page_num)
        blocks = page.get_text("dict")["blocks"]
        page_blocks = []
        for block in blocks:
            if "lines" in block:
                block_text = ""
                block_bbox = None
                for line in block["lines"]:
                    for span in line["spans"]:
                        if span["text"].strip():
                            bbox = span["bbox"]
                            if isinstance(bbox, (list, tuple)) and len(bbox) == 4:
                                bbox = [float(coord) for coord in bbox]
                                if block_bbox is None:
                                    block_bbox = bbox
                                else:
                                    block_bbox[0] = min(block_bbox[0], bbox[0])
                                    block_bbox[1] = min(block_bbox[1], bbox[1])
                                    block_bbox[2] = max(block_bbox[2], bbox[2])
                                    block_bbox[3] = max(block_bbox[3], bbox[3])
                                block_text += span["text"] + " "
                if block_text.strip():
                    page_blocks.append({
                        "text": block_text.strip(),
                        "bbox": block_bbox
                    })
        pages_blocks.append(page_blocks)
    return pages_blocks

def translate_text(text, dest_language):
    translator = Translator()
    try:
        translation = translator.translate(text, dest=dest_language)
        return translation.text
    except Exception as e:
        print(f"Translation error for text: '{text}'")
        print(e)
        return None

def create_translated_pdf(input_pdf_path, output_pdf_path, dest_language='en'):
    doc = fitz.open(input_pdf_path)
    pages_blocks = extract_text_blocks(input_pdf_path)

    for page_num, page_blocks in enumerate(pages_blocks):
        page = doc.load_page(page_num)
        for block in page_blocks:
            text = block["text"]
            bbox = block["bbox"]

            print(f"Processing block: '{text}' with bbox: {bbox}")

            if isinstance(bbox, (list, tuple)) and len(bbox) == 4:
                try:
                    rect = fitz.Rect(bbox)
                    translated_text = translate_text(text, dest_language)

                    if translated_text:
                        page.add_redact_annot(rect, text="")
                        page.apply_redactions()

                        html = f'''
                        <div style="font-size:12px; text-align:justify;">
                            {translated_text}
                        </div>
                        '''                        
                        page.insert_htmlbox(rect, html)
                    else:
                        print(f"Skipping block due to translation error: '{text}'")
                except Exception as e:
                    print(f"Error processing block: '{text}' with bbox: {bbox}")
                    print(e)
            else:
                print(f"Invalid bbox: {bbox}")

    doc.save(output_pdf_path)

if __name__ == "__main__":
    input_pdf = "input.pdf" 
    output_pdf = "output_translated.pdf"  
    dest_lang = 'es'  
    create_translated_pdf(input_pdf, output_pdf, dest_lang)

[JorjMcKie]

To provide inserted text with desired font weight / style always requires using the right (= different!) font. I.e. bold text means a different font was used than regular or italic text. So to cover all situations for e.g. Helvetica, you need 4 different fonts: Helvetica, Helvetica-Bold, Helvetica-BoldItalic and Helvetica-Italic.

[bqhai199x]

Hello NikitaIVll, how is your project to translate PDF files going? I have a similar issue and would like to know how you are handling it.