Classify Document

import time
import asyncio

async def poll_classification_status(job_id, max_wait_time=300):
    """Poll classification job status with exponential backoff"""
    
    base_delay = 1  # Start with 1 second
    max_delay = 30  # Maximum delay between polls
    current_delay = base_delay
    total_wait_time = 0
    
    while total_wait_time < max_wait_time:
        try:
            response = requests.get(
                f"https://prod.visionapi.unsiloed.ai/classify/{job_id}",
                headers={"api-key": "your-api-key", "Content-Type": "application/json"}
            )
            
            if response.status_code == 200:
                result = response.json()
                
                if result['status'] == 'completed':
                    return result['result']
                elif result['status'] == 'failed':
                    raise Exception(f"Classification failed: {result.get('error', 'Unknown error')}")
                else:
                    print(f"Status: {result['status']}, Progress: {result.get('progress', 'N/A')}")
            
            # Wait before next poll
            await asyncio.sleep(current_delay)
            total_wait_time += current_delay
            
            # Exponential backoff
            current_delay = min(current_delay * 2, max_delay)
            
        except Exception as e:
            print(f"Error polling status: {e}")
            await asyncio.sleep(current_delay)
            total_wait_time += current_delay
    
    raise Exception("Classification job timed out")

conditions = [
    "invoice - Business invoices with itemized charges, payment terms, and vendor information",
    "contract - Legal agreements including terms of service, NDAs, and binding documents",
    "report - Analytical reports, financial statements, and data presentations",
    "letter - Correspondence, memos, and communication documents"
]

import asyncio
import aiohttp

async def classify_documents(file_paths, conditions):
    """Classify multiple documents concurrently"""
    
    async def classify_single(session, file_path):
        data = aiohttp.FormData()
        data.add_field('pdf_file', open(file_path, 'rb'), filename=file_path)
        data.add_field('conditions', json.dumps(conditions))
        
        async with session.post(
            'https://prod.visionapi.unsiloed.ai/classify',
            headers={'api-key': 'your-api-key'},
            data=data
        ) as response:
            return await response.json()
    
    async with aiohttp.ClientSession() as session:
        tasks = [classify_single(session, path) for path in file_paths]
        results = await asyncio.gather(*tasks)
        return results

# Usage
file_paths = ['doc1.pdf', 'doc2.pdf', 'doc3.pdf']
conditions = ['invoice', 'contract', 'report']
results = asyncio.run(classify_documents(file_paths, conditions))

import time
import random

async def classify_with_retry(pdf_path, conditions, max_retries=3):
    """Classify document with exponential backoff retry"""
    
    for attempt in range(max_retries + 1):
        try:
            files = {"pdf_file": open(pdf_path, "rb")}
            data = {"conditions": json.dumps(conditions)}
            
            response = requests.post(
                "https://prod.visionapi.unsiloed.ai/classify",
                headers={"api-key": "your-api-key"},
                files=files,
                data=data
            )
            
            if response.status_code == 202:
                result = response.json()
                job_id = result["job_id"]
                
                # Poll for completion
                return await poll_classification_status(job_id)
            else:
                response.raise_for_status()
                
        except Exception as e:
            if attempt < max_retries:
                # Exponential backoff with jitter
                wait_time = (2 ** attempt) + random.uniform(0, 1)
                time.sleep(wait_time)
                continue
            else:
                raise e
        finally:
            if 'files' in locals():
                files["pdf_file"].close()