Python implements intelligent extraction and synthesis of word document content

pip install python-docx Pillow requests # If you need to call the LLM API# Other libraries may be required, depending on the implementation

import os
from docx import Document
from  import Inches
# You may need to import other modules, such as processing XML or calling APIs
# --- Configuration ---SOURCE_DOCS_DIR = 'files/transform/docx/source_documents'
TARGET_TEMPLATE = 'files/transform/docx/'
OUTPUT_DOC_PATH = 'files/transform/docx/generated_document.docx'
EXTRACTION_RULES = { # Sample rules need to be modified according to your actual situation    'source_doc_1.docx': {'heading_start': 'Chapter 3', 'heading_end': 'Chapter 4'},
    'source_doc_2.docx': {'style_name': 'SourceHighlight'},
    # ... Rules for other documents}

# --- Helper function (example) ---def should_extract_paragraph(paragraph, rules):
    # Implement the logic of determining whether a paragraph should be extracted based on rules    # For example: Check whether the paragraph text matches, whether the style matches, etc.    # Return True or False    # (This part of the logic needs to be written according to your specific rules)    style_name = 
    text = ()
    # Example: Simple style-based rules    if 'style_name' in rules and style_name == rules['style_name']:
        return True
    # Example: Simple rules based on the starting title (status management is required)    # if 'heading_start' in rules ... (A more complex logic is required to track the current chapter)    return False # No extraction by default
def extract_content_from_doc(source_path, rules):
    """Extract content from a single source document"""
    extracted_elements = []
    try:
        source_doc = Document(source_path)
        # If the tag is in the extraction area (for example, between specific chapters)        in_extraction_zone = False # The initial state needs to be adjusted according to the rules
        for element in source_doc.:
            # Handle different types of elements: paragraphs, tables, etc.            if ('p'): # is a paragraph                paragraph = (element, source_doc)

                # --- Core extraction logic ---                # Here you need to implement complex judgment logic based on your EXTRACTION_RULES                # For example, determine whether the starting title is encountered, whether the end title is encountered, whether the paragraph style matches, etc.                # This is a simplified example that may actually require more granular state management                if 'heading_start' in rules and ('Heading') and rules['heading_start'] in :
                    in_extraction_zone = True
                    continue # Do not extract the starting title itself?  Depend on demand                if 'heading_end' in rules and ('Heading') and rules['heading_end'] in :
                    in_extraction_zone = False
                    continue # Arrive the end title and stop extracting
                if in_extraction_zone or should_extract_paragraph(paragraph, rules):
                     # Extract text content                    text_content = 
                     # Try to extract basic formats (bold, italic) - It is more complicated, and may need to traverse runs                    # TODO: Extract the picture (need to check the inline_shapes in the paragraph or the drawing in runs)                    # TODO: Extracting formulas (extremely challenging, see discussion below)                    extracted_elements.append({'type': 'paragraph', 'text': text_content, 'style': }) # Can carry source style names for reference
            elif ('tbl'): # Yes a table                table = (element, source_doc)
                # --- Extract form ---                # TODO: Implementing table extraction logic, you may need to check whether it is within the extraction area                # if in_extraction_zone or table_should_be_extracted(table, rules):
                table_data = []
                for row in :
                    row_data = [ for cell in ]
                    table_data.append(row_data)
                extracted_elements.append({'type': 'table', 'data': table_data})

            # --- Processing pictures ---            # Find pictures in paragraphs (inline_shapes)            # paragraph = (element, source_doc) # Re-get paragraph object if needed
            # for run in :
            #     if ('.//wp:inline | .//wp:anchor'): # Check for drawings
            #         # This part is complex: need to get image data (rId) and relate it back
            #         # to the actual image part in the docx package.
            #         # python-docx can extract images, but associating them perfectly
            #         # with their original position during extraction requires care.
            #         # Placeholder:
            #         # image_data = get_image_data(run, source_doc)
            #         # if image_data:
            #         #    extracted_elements.append({'type': 'image', 'data': image_data, 'filename': f'img_{len(extracted_elements)}.png'})
            pass # Placeholder for image extraction logic

    except Exception as e:
        print(f"Error processing {source_path}: {e}")
    return extracted_elements

# --- Main process ---all_extracted_content = []
source_files = [f for f in (SOURCE_DOCS_DIR) if ('.docx')]

for filename in source_files:
    source_path = (SOURCE_DOCS_DIR, filename)
    rules = EXTRACTION_RULES.get(filename, {}) # Get the extraction rules for this file    if rules: # Only process files that define rules        print(f"Extracting from: {filename}")
        content = extract_content_from_doc(source_path, rules)
        all_extracted_content.extend(content)
    else:
        print(f"Skipping {filename}, no rules defined.")

print(f"Total elements extracted: {len(all_extracted_content)}")

# --- ---
import requests
import json

# --- Configure LLM ---LLM_API_URL = "YOUR_LLM_API_ENDPOINT" # ., OpenAI API URL
LLM_API_KEY = "YOUR_LLM_API_KEY"
LLM_PROMPT_TEMPLATE = """
 Please rewrite this text according to the following requirements:
 Target language style: [Described in detail here, for example: formal, objective, concise]
 Word Specifications: [List the specifications here, for example: use "user" instead of "customer", avoid using abbreviations]
 Grammar habits: [Described here, for example: use active voice more often, and the sentence length is moderate]
 Target audience: [Describe the target readers]

 original:
 "{text}"

 Rewritten text:
 """

def adapt_text_style(text):
    """Using the LLM API to adjust text style"""
    if not ():
        return text # Skip empty text
    prompt = LLM_PROMPT_TEMPLATE.format(text=text)
    headers = {
        "Authorization": f"Bearer {LLM_API_KEY}",
        "Content-Type": "application/json",
    }
    data = {
        "model": "gpt-4", # or the model you use        "prompt": prompt,
        "max_tokens": 1024, #Adjust as needed        "temperature": 0.5, # Control creativity, lower values ​​are more conservative    }
    try:
        response = (LLM_API_URL, headers=headers, json=data)
        response.raise_for_status() # Check for HTTP errors        result = ()
        # Analyze the results returned by LLM, note that the formats of different APIs may be different        rewritten_text = result['choices'][0]['text'].strip() # Sample path        print(f"Original: {text[:50]}... | Rewritten: {rewritten_text[:50]}...")
        return rewritten_text
    except  as e:
        print(f"Error calling LLM API: {e}")
        return text # Return to the original text when an error occurs    except (KeyError, IndexError) as e:
        print(f"Error parsing LLM response: {e} - Response: {}")
        return text # Return to the original text when an error occurs
# --- Apply style adjustment ---adjusted_content = []
for element in all_extracted_content:
    if element['type'] == 'paragraph':
        # --- Calling the LLM API ---        # adjusted_text = adapt_text_style(element['text'])
        # element['text'] = adjusted_text # Update text        # --- Or do not call it first, and wait until it is generated before processing ---        adjusted_content.append(element)
    elif element['type'] == 'table':
         # Table content can also be processed cell by cell, but may not work well or costly         # A better approach might be to organize the table content into text and describe it to the LLM, or to process it manually         adjusted_content.append(element)
    elif element['type'] == 'image':
         # The image cannot be processed directly         adjusted_content.append(element)
    # Handle other types...
# --- (Continued to the next stage: document generation) ---

# --- (Continued) ---
# --- Create target document (based on templates) ---try:
    target_doc = Document(TARGET_TEMPLATE)
except Exception as e:
    print(f"Error loading template {TARGET_TEMPLATE}: {e}")
    # You can consider creating an empty document as a backup    # target_doc = Document()
    exit()


# --- Fill in content and apply styles ---for element in adjusted_content: # Use adjusted content, or original extracted content    if element['type'] == 'paragraph':
        text = element['text']
        # --- Core: Styles defined in the application template ---        # Simple way: All paragraphs apply default text styles        # target_doc.add_paragraph(text, style='TargetBodyText') # Assume that this style is in the template
        # Complex way: determine which target style to apply based on source document information or content        # Example: If the source style is Heading 1, apply TargetHeading1        source_style = ('style', '') # Get the source style name (if saved during extraction)        if source_style.startswith('Heading 1'):
             target_doc.add_paragraph(text, style='TargetHeading1') # Assume that this style is present in the template        elif source_style.startswith('Heading 2'):
             target_doc.add_paragraph(text, style='TargetHeading2')
        # ... Other style mapping rules        else:
             target_doc.add_paragraph(text, style='TargetBodyText') # Default Style
    elif element['type'] == 'table':
        table_data = element['data']
        if table_data:
            # Create a table            num_rows = len(table_data)
            num_cols = len(table_data[0]) if num_rows > 0 else 0
            if num_rows > 0 and num_cols > 0:
                # --- Apply the table style defined in the template ---                table = target_doc.add_table(rows=num_rows, cols=num_cols, style='TargetTableStyle') # Assume that this table style is present in the template                # Fill in data                for i, row_data in enumerate(table_data):
                    for j, cell_text in enumerate(row_data):
                        # Prevent column mismatch errors                        if j < len([i].cells):
                            [i].cells[j].text = cell_text
                # You can add more table formatting codes, such as setting column widths, etc.
    elif element['type'] == 'image':
        # --- Add picture ---        # image_data = element['data']
        # image_filename = element['filename']
        # # You need to save image_data as a temporary file or use BytesIO        # from io import BytesIO
        # image_stream = BytesIO(image_data)
        # try:
        # target_doc.add_picture(image_stream, width=Inches(4.0)) # Adjust width        # except Exception as e:
        #    print(f"Error adding image {image_filename}: {e}")
        pass # Placeholder for image insertion

    # --- Processing Formulas (Challenge) ---    # If the formula is extracted as a picture:    #   elif element['type'] == 'formula_image':
    # # Add image...    # If the formula is extracted as MathML/OMML (XML string):    #   elif element['type'] == 'formula_mathml':
    # # It's hard to insert MathML directly using python-docx    # # You may need to operate OOXML directly (very complex)    # # Or, insert a placeholder "[FORMULA]" into the paragraph and replace it manually    #       target_doc.add_paragraph(f"[FORMULA: {element['id']}]", style='TargetBodyText')
    # If the formula is extracted as a plain text approximation:    #   elif element['type'] == 'formula_text':
    # target_doc.add_paragraph(element['text'], style='FormulaStyle') # Special styles may be required
# --- Save the final document ---try:
    target_doc.save(OUTPUT_DOC_PATH)
    print(f"Document successfully generated: {OUTPUT_DOC_PATH}")
except Exception as e:
    print(f"Error saving document: {e}")