Invoice Processing Tutorial

import requests
import time
import logging
from typing import Dict, Any, Optional, List

logger = logging.getLogger(__name__)

class InvoiceProcessor:
    def __init__(self, api_key: str, base_url: str = "https://api.documind.cloud/api/v1"):
        self.api_key = api_key
        self.base_url = base_url
        self.headers = {"X-API-Key": api_key}
        self.schema = self._load_schema()
    
    def _load_schema(self) -> Dict[str, Any]:
        """Load invoice schema"""
        import json
        with open("invoice_schema.json") as f:
            return json.load(f)
    
    def upload_invoice(self, file_path: str) -> str:
        """Upload an invoice and return document ID"""
        logger.info(f"Uploading {file_path}...")
        
        with open(file_path, "rb") as f:
            files = {"files": f}
            response = requests.post(
                f"{self.base_url}/upload",
                headers=self.headers,
                files=files
            )
        
        response.raise_for_status()
        document_id = response.json()[0]
        logger.info(f"Uploaded successfully: {document_id}")
        
        return document_id
    
    def extract_invoice(
        self,
        document_id: str,
        mode: str = "basic",
        model: str = "qwen-3-vl"
    ) -> Dict[str, Any]:
        """Extract invoice data"""
        logger.info(f"Extracting invoice {document_id} in {mode} mode...")
        
        payload = {
            "schema": self.schema,
            "prompt": self._get_extraction_prompt()
        }
        
        # Add mode-specific parameters
        if mode == "basic":
            payload["model"] = model
        elif mode == "advanced":
            payload["review_threshold"] = 85
        
        response = requests.post(
            f"{self.base_url}/extract/{document_id}",
            headers=self.headers,
            json=payload,
            timeout=120
        )
        
        response.raise_for_status()
        result = response.json()
        logger.info(f"Extraction complete. Needs review: {result['needs_review']}")
        
        return result
    
    def _get_extraction_prompt(self) -> str:
        """Get extraction prompt for invoices"""
        return """
        Extract invoice information accurately from this document.
        
        Instructions:
        - Invoice number is typically in the header, labeled 'Invoice #' or 'Invoice Number'
        - Use YYYY-MM-DD format for dates
        - Extract ALL line items from the table, including description, quantity, unit price, and amount
        - The total is the final amount due, including tax
        - Vendor information is usually at the top or 'From' section
        - Customer information is in the 'Bill To' or 'Customer' section
        - If a field is not found, return null
        
        Be precise with numeric values and ensure line items sum correctly.
        """
    
    def wait_for_review(
        self,
        document_id: str,
        timeout: int = 300,
        poll_interval: int = 10
    ) -> Optional[Dict[str, Any]]:
        """Wait for human review to complete"""
        logger.info(f"Waiting for review of {document_id}...")
        
        start_time = time.time()
        
        while (time.time() - start_time) < timeout:
            response = requests.get(
                f"{self.base_url}/data/extractions",
                headers=self.headers,
                params={"document_id": document_id}
            )
            
            response.raise_for_status()
            data = response.json()
            
            if data["items"]:
                extraction = data["items"][0]
                
                if extraction["is_reviewed"]:
                    logger.info("Review complete!")
                    return extraction["reviewed_results"]
            
            time.sleep(poll_interval)
        
        logger.error(f"Review not completed within {timeout}s")
        return None
    
    def process_invoice(
        self,
        file_path: str,
        mode: str = "basic"
    ) -> Dict[str, Any]:
        """Complete invoice processing workflow"""
        # Upload
        document_id = self.upload_invoice(file_path)
        
        # Extract
        result = self.extract_invoice(document_id, mode=mode)
        
        # Handle review if needed
        if result["needs_review"]:
            logger.info("Invoice flagged for review. Waiting...")
            reviewed_results = self.wait_for_review(document_id)
            if reviewed_results:
                result["results"] = reviewed_results
                result["is_reviewed"] = True
        
        return {
            "document_id": document_id,
            "data": result["results"],
            "needs_review": result["needs_review"],
            "is_reviewed": result.get("is_reviewed", False)
        }

# Usage
processor = InvoiceProcessor(api_key="your_api_key_here")
result = processor.process_invoice("invoice.pdf", mode="basic")
print(f"Invoice Number: {result['data']['invoice_number']}")
print(f"Total: ${result['data']['total']}")

const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');

class InvoiceProcessor {
  constructor(apiKey, baseUrl = 'https://api.documind.cloud/api/v1') {
    this.apiKey = apiKey;
    this.baseUrl = baseUrl;
    this.headers = { 'X-API-Key': apiKey };
    this.schema = JSON.parse(fs.readFileSync('invoice_schema.json', 'utf8'));
  }

  async uploadInvoice(filePath) {
    console.log(`Uploading ${filePath}...`);
    
    const form = new FormData();
    form.append('files', fs.createReadStream(filePath));
    
    const response = await axios.post(
      `${this.baseUrl}/upload`,
      form,
      {
        headers: {
          ...form.getHeaders(),
          ...this.headers
        }
      }
    );
    
    const documentId = response.data[0];
    console.log(`Uploaded successfully: ${documentId}`);
    
    return documentId;
  }

  async extractInvoice(documentId, mode = 'basic', model = 'qwen-3-vl') {
    console.log(`Extracting invoice ${documentId} in ${mode} mode...`);
    
    const payload = {
      schema: this.schema,
      prompt: this.getExtractionPrompt()
    };
    
    if (mode === 'basic') {
      payload.model = model;
    } else if (mode === 'advanced') {
      payload.review_threshold = 85;
    }
    
    const response = await axios.post(
      `${this.baseUrl}/extract/${documentId}`,
      payload,
      {
        headers: this.headers,
        timeout: 120000
      }
    );
    
    console.log(`Extraction complete. Needs review: ${response.data.needs_review}`);
    
    return response.data;
  }

  getExtractionPrompt() {
    return `
    Extract invoice information accurately from this document.
    
    Instructions:
    - Invoice number is typically in the header
    - Use YYYY-MM-DD format for dates
    - Extract ALL line items from the table
    - The total is the final amount due, including tax
    - If a field is not found, return null
    `;
  }

  async waitForReview(documentId, timeout = 300000, pollInterval = 10000) {
    console.log(`Waiting for review of ${documentId}...`);
    
    const startTime = Date.now();
    
    while ((Date.now() - startTime) < timeout) {
      const response = await axios.get(
        `${this.baseUrl}/data/extractions`,
        {
          headers: this.headers,
          params: { document_id: documentId }
        }
      );
      
      if (response.data.items.length > 0) {
        const extraction = response.data.items[0];
        
        if (extraction.is_reviewed) {
          console.log('Review complete!');
          return extraction.reviewed_results;
        }
      }
      
      await new Promise(resolve => setTimeout(resolve, pollInterval));
    }
    
    console.error('Review not completed within timeout');
    return null;
  }

  async processInvoice(filePath, mode = 'basic') {
    const documentId = await this.uploadInvoice(filePath);
    const result = await this.extractInvoice(documentId, mode);
    
    if (result.needs_review) {
      console.log('Invoice flagged for review. Waiting...');
      const reviewedResults = await this.waitForReview(documentId);
      if (reviewedResults) {
        result.results = reviewedResults;
        result.is_reviewed = true;
      }
    }
    
    return {
      document_id: documentId,
      data: result.results,
      needs_review: result.needs_review,
      is_reviewed: result.is_reviewed || false
    };
  }
}

// Usage
const processor = new InvoiceProcessor('your_api_key_here');
processor.processInvoice('invoice.pdf', 'basic')
  .then(result => {
    console.log(`Invoice Number: ${result.data.invoice_number}`);
    console.log(`Total: $${result.data.total}`);
  });