Announcing the Python SDK for Nutrient DWS Processor API

import asyncio
from nutrient_dws import NutrientClient

client = NutrientClient(api_key='your_api_key')

# Type-hinted method calls with full IDE support.
async def main():
    pdf_result = await client.convert('document.docx', 'pdf')
    text_result = await client.extract_text('scanned.pdf')

    # Access typed results.
    pdf_buffer = pdf_result['buffer']
    print(text_result['data']['pages'][0]['plainText'])

asyncio.run(main())

# Simple conversion with smart defaults.
pdf = await client.convert('document.docx', 'pdf')

# Or customize every aspect via workflow.
pdf = await (client
    .workflow()
    .add_file_part('document.docx')
    .output_pdfa({
        'conformance': 'pdfa-2b',
        'optimize': {
            'mrcCompression': True,
            'imageOptimizationQuality': 3
        }
    })
    .execute())

from nutrient_dws.builder.constant import BuildActions

result = await (client
    .workflow()
    # Stage 1: Combine multiple documents into one workflow.
    .add_file_part('contract.pdf')
    .add_file_part('appendix.pdf')

    # Stage 2: Apply actions — process the combined documents.
    .apply_action(BuildActions.watermark_text('CONFIDENTIAL', {
        'opacity': 0.5,
        'fontSize': 48
    }))
    .apply_action(BuildActions.create_redactions_preset('email-address'))

    # Stage 3: Set output format — specify final document properties.
    .output_pdf({
        'optimize': {
            'mrcCompression': True,
            'imageOptimizationQuality': 2
        }
    })

    # Stage 4: Execute — run the entire workflow and get results.
    .execute())

import asyncio
from nutrient_dws import NutrientClient

async def main():
    client = NutrientClient(api_key='your_api_key')

    # Convert documents.
    pdf_result = await client.convert('presentation.pptx', 'pdf')

    # Access the converted PDF buffer.
    pdf_buffer = pdf_result['buffer']
    with open('presentation.pdf', 'wb') as f:
        f.write(pdf_buffer)

    # Merge multiple PDFs.
    merged = await client.merge(['doc1.pdf', 'doc2.pdf'])

    # Add watermarks.
    watermarked = await client.watermark_text('document.pdf', 'DRAFT')

    # Extract data.
    extracted_text = await client.extract_text('scanned.pdf')

    # Access extracted text.
    text_content = extracted_text['data']['pages'][0]['plainText']
    print(text_content)

asyncio.run(main())

from nutrient_dws.builder.constant import BuildActions

# Process contracts end to end.
async def process_contract(contract_file: str):
    # Stage 1: Combine, watermark, and archive documents in a single workflow.
    combined = await (client
        .workflow()
        .add_file_part(contract_file)
        .add_file_part('terms-and-conditions.pdf')
        .apply_action(BuildActions.watermark_text('CONFIDENTIAL'))
        .output_pdfa({
            'conformance': 'pdfa-2b',
            'optimize': {'mrcCompression': True}
        })
        .execute())

    # Stage 2: Apply a digital signature for legal compliance.
    signed = await client.sign(combined['output']['buffer'], {
        'signatureType': 'cades',
        'cadesLevel': 'b-lt'
    })

    return signed

async def process_invoices(invoice_files: list[str]):
    """Extract data from multiple invoices and compile results"""
    import asyncio

    async def process_single_invoice(invoice_file: str):
        # OCR the invoice if it's a scanned image.
        ocr_result = await client.ocr(invoice_file, 'english')

        # Extract key-value pairs from the OCR result.
        kvp_result = await client.extract_key_value_pairs(ocr_result['buffer'])

        return {
            'file': invoice_file,
            'data': kvp_result['data']
        }

    # Process invoices concurrently using `asyncio.gather`.
    results = await asyncio.gather(
        *[process_single_invoice(file) for file in invoice_files]
    )

    return results

from nutrient_dws.builder.constant import BuildActions

# Multistep redaction with different strategies.
async def redact_sensitive_info(document: str):
    return await (client
        .workflow()
        .add_file_part(document)
        .apply_actions([
            # Strategy 1: Target specific known content with exact text matching.
            BuildActions.create_redactions_text('Account Number: 12345'),

            # Strategy 2: Use built-in patterns for common sensitive data types.
            BuildActions.create_redactions_preset('email-address'),
            BuildActions.create_redactions_preset('credit-card-number'),

            # Permanently remove all marked content.
            BuildActions.apply_redactions()
        ])
        .output_pdf()
        .execute())