import time
from leapocr import LeapOCR

client = LeapOCR(api_key='your-api-key')

def monitor_job(job_id: str):
    while True:
        try:
            status = client.get_status(job_id)
            print(f"Progress: {status.progress}%")
            
            if status.status == 'completed':
                result = client.get_result(job_id)
                print(f"OCR Results: {result.data}")
                
                # Process extracted data
                for i, page in enumerate(result.pages):
                    print(f"Page {i + 1}: {page.extracted_text}")
                break
            elif status.status == 'failed':
                print(f"Job failed: {status.error}")
                break
                
            time.sleep(2)
        except Exception as error:
            print(f"Status check failed: {error}")
            break

package main

import (
    "fmt"
    "log"
    "time"
    
    "github.com/leapocr/go-sdk"
)

func monitorJob(client *leapocr.Client, jobID string) {
    for {
        status, err := client.GetStatus(jobID)
        if err != nil {
            log.Printf("Status check failed: %v", err)
            return
        }
        
        fmt.Printf("Progress: %d%%
", status.Progress)
        
        switch status.Status {
        case "completed":
            result, err := client.GetResult(jobID)
            if err != nil {
                log.Printf("Failed to get result: %v", err)
                return
            }
            
            fmt.Printf("OCR Results: %+v
", result.Data)
            
            // Process extracted data
            for i, page := range result.Pages {
                fmt.Printf("Page %d: %s
", i+1, page.ExtractedText)
            }
            return
        case "failed":
            fmt.Printf("Job failed: %s
", status.Error)
            return
        }
        
        time.Sleep(2 * time.Second)
    }
}

# Check status
curl -X GET https://api.leapocr.com/v1/jobs/job_abc123/status \
  -H "Authorization: Bearer your-api-key"

# Response
{
  "jobId": "job_abc123",
  "status": "processing",
  "progress": 45,
  "message": "Processing page 2 of 4"
}

# Get results when completed
curl -X GET https://api.leapocr.com/v1/jobs/job_abc123/result \
  -H "Authorization: Bearer your-api-key"

from leapocr import LeapOCR

client = LeapOCR(api_key='your-api-key')

# Define a custom schema for invoice processing
invoice_schema = {
    "type": "object",
    "properties": {
        "vendor": {"type": "string"},
        "invoice_number": {"type": "string"},
        "date": {"type": "string", "format": "date"},
        "total": {"type": "number"},
        "tax": {"type": "number"},
        "line_items": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "description": {"type": "string"},
                    "quantity": {"type": "number"},
                    "unit_price": {"type": "number"},
                    "total": {"type": "number"}
                }
            }
        }
    },
    "required": ["vendor", "total", "date"]
}

def process_invoice(file_path: str) -> str:
    with open(file_path, 'rb') as file:
        response = client.upload(
            file=file,
            schema=invoice_schema,
            category='invoice'
        )
    
    return response.job_id

package main

import (
    "encoding/json"
    "os"
    
    "github.com/leapocr/go-sdk"
)

// Define invoice schema structure
type InvoiceSchema struct {
    Type       string                 `json:"type"`
    Properties map[string]interface{} `json:"properties"`
    Required   []string               `json:"required"`
}

func main() {
    client := leapocr.NewClient("your-api-key")
    
    // Define custom schema for invoice processing
    schema := InvoiceSchema{
        Type: "object",
        Properties: map[string]interface{}{
            "vendor":        map[string]string{"type": "string"},
            "invoiceNumber": map[string]string{"type": "string"},
            "date":          map[string]interface{}{"type": "string", "format": "date"},
            "total":         map[string]string{"type": "number"},
            "tax":           map[string]string{"type": "number"},
        },
        Required: []string{"vendor", "total", "date"},
    }
    
    file, _ := os.Open("invoice.pdf")
    defer file.Close()
    
    response, err := client.Upload(&leapocr.UploadRequest{
        File:     file,
        Schema:   schema,
        Category: "invoice",
    })
    
    if err == nil {
        println("Job ID:", response.JobID)
    }
}

curl -X POST https://api.leapocr.com/v1/upload \
  -H "Authorization: Bearer your-api-key" \
  -H "Content-Type: multipart/form-data" \
  -F "file=@invoice.pdf" \
  -F "category=invoice" \
  -F 'schema={
    "type": "object",
    "properties": {
      "vendor": {"type": "string"},
      "invoiceNumber": {"type": "string"},
      "date": {"type": "string", "format": "date"},
      "total": {"type": "number"},
      "tax": {"type": "number"}
    },
    "required": ["vendor", "total", "date"]
  }'

import asyncio
from leapocr import LeapOCR
from typing import List

client = LeapOCR(api_key='your-api-key')

class DocumentProcessor:
    def __init__(self):
        self.jobs = {}
    
    async def process_batch(self, file_paths: List[str], category: str = 'default'):
        tasks = []
        for file_path in file_paths:
            task = self.upload_document(file_path, category)
            tasks.append(task)
        
        job_ids = await asyncio.gather(*tasks, return_exceptions=True)
        return [job_id for job_id in job_ids if isinstance(job_id, str)]
    
    async def upload_document(self, file_path: str, category: str):
        try:
            with open(file_path, 'rb') as file:
                response = client.upload(
                    file=file,
                    category=category,
                    custom_instructions='Extract all text and key data points'
                )
            
            self.jobs[response.job_id] = {
                'filename': file_path,
                'status': 'processing',
                'start_time': time.time()
            }
            
            return response.job_id
        except Exception as error:
            print(f"Failed to upload {file_path}: {error}")
            return None
    
    async def monitor_batch(self, job_ids: List[str]):
        tasks = [self.wait_for_completion(job_id) for job_id in job_ids]
        results = await asyncio.gather(*tasks)
        return results
    
    async def wait_for_completion(self, job_id: str):
        while True:
            status = client.get_status(job_id)
            if status.status == 'completed':
                return client.get_result(job_id)
            await asyncio.sleep(1)

# Usage
processor = DocumentProcessor()
file_paths = ['invoice1.pdf', 'invoice2.pdf', 'receipt.pdf']
job_ids = await processor.process_batch(file_paths, 'invoice')

package main

import (
    "sync"
    "time"
    
    "github.com/leapocr/go-sdk"
)

type DocumentProcessor struct {
    client *leapocr.Client
    jobs   map[string]JobInfo
    mutex  sync.RWMutex
}

type JobInfo struct {
    Filename  string
    Status    string
    StartTime time.Time
}

func NewDocumentProcessor(apiKey string) *DocumentProcessor {
    return &DocumentProcessor{
        client: leapocr.NewClient(apiKey),
        jobs:   make(map[string]JobInfo),
    }
}

func (dp *DocumentProcessor) ProcessBatch(filePaths []string, category string) ([]string, error) {
    var wg sync.WaitGroup
    jobChan := make(chan string, len(filePaths))
    
    for _, filePath := range filePaths {
        wg.Add(1)
        go func(path string) {
            defer wg.Done()
            
            file, err := os.Open(path)
            if err != nil {
                return
            }
            defer file.Close()
            
            response, err := dp.client.Upload(&leapocr.UploadRequest{
                File:     file,
                Category: category,
                CustomInstructions: "Extract all text and key data points",
            })
            
            if err == nil {
                dp.mutex.Lock()
                dp.jobs[response.JobID] = JobInfo{
                    Filename:  path,
                    Status:    "processing",
                    StartTime: time.Now(),
                }
                dp.mutex.Unlock()
                
                jobChan <- response.JobID
            }
        }(filePath)
    }
    
    wg.Wait()
    close(jobChan)
    
    var jobIDs []string
    for jobID := range jobChan {
        jobIDs = append(jobIDs, jobID)
    }
    
    return jobIDs, nil
}

#!/bin/bash

# Batch upload multiple files
FILES=("invoice1.pdf" "invoice2.pdf" "receipt.pdf")
JOB_IDS=()

for file in "${FILES[@]}"; do
    response=$(curl -s -X POST https://api.leapocr.com/v1/upload \
        -H "Authorization: Bearer your-api-key" \
        -H "Content-Type: multipart/form-data" \
        -F "file=@$file" \
        -F "category=invoice")
    
    job_id=$(echo "$response" | jq -r '.jobId')
    JOB_IDS+=("$job_id")
    echo "Uploaded $file: $job_id"
done

# Monitor all jobs
for job_id in "${JOB_IDS[@]}"; do
    echo "Monitoring $job_id..."
    while true; do
        status=$(curl -s -X GET https://api.leapocr.com/v1/jobs/$job_id/status \
            -H "Authorization: Bearer your-api-key" | jq -r '.status')
        
        if [[ "$status" == "completed" ]]; then
            curl -X GET https://api.leapocr.com/v1/jobs/$job_id/result \
                -H "Authorization: Bearer your-api-key"
            break
        fi
        sleep 2
    done
done