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())

dws-add-claude-code-rule
dws-add-github-copilot-rule
dws-add-junie-rule
dws-add-cursor-rule
dws-add-windsurf-rule

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())