Copiar. Pegar. Implementar. |

# Produktion: Mit Token | Test: Ohne Token (VISITOR Mode)
import requests

def process_invoice(pdf_path, token=None):
    # Header nur wenn Token vorhanden
    headers = {"Authorization": f"Bearer {token}"} if token else {}
    
    # 1. AI-IDP mit Bounding Boxes
    response = requests.post(
        "https://api.paperoffice.ai/latest/job",
        headers=headers,
        files={"file_1": open(pdf_path, "rb")},
        data={
            "model": "premium",
            "idp_collection": "invoice",
            "priority": 900
        }
    )
    
    invoice = response.json()["job_result"]
    
    # 2. Bounding Boxes für Review
    for field, data in invoice["fields"].items():
        if data.get("confidence", 0) < 0.9:
            print(f"⚠️ Review: {field} @ bbox {data['bbox']}")
    
    # 3. Export für Buchhaltung
    return {
        "vendor": invoice["fields"]["vendor"]["value"],
        "amount": invoice["fields"]["total"]["value"],
        "date": invoice["fields"]["date"]["value"],
        "iban": invoice["fields"]["iban"]["value"]
    }

# Test ohne Token (VISITOR Mode)
process_invoice("invoice.pdf")

# Produktion mit Token
process_invoice("invoice.pdf", "po_usr_YOUR_TOKEN")

# Produktion: Mit Token | Test: Ohne Token (VISITOR Mode)
import requests

def analyze_contract(pdf_path, token=None):
    headers = {"Authorization": f"Bearer {token}"} if token else {}
    
    # Vertrag analysieren mit AI-IDP
    response = requests.post(
        "https://api.paperoffice.ai/latest/job",
        headers=headers,
        files={"file_1": open(pdf_path, "rb")},
        data={
            "model": "premium",
            "idp_collection": "contract",
            "priority": 900
        }
    )
    
    contract = response.json()["job_result"]
    
    # Key Terms extrahieren (mit Bounding Boxes!)
    key_terms = {
        "parties": contract["fields"]["parties"],
        "start_date": contract["fields"]["start_date"],
        "end_date": contract["fields"]["end_date"],
        "notice_period": contract["fields"]["notice_period"]
    }
    
    # Jedes Feld hat bbox für Verification
    for field, data in key_terms.items():
        print(f"{field}: {data['value']} @ {data['bbox']}")
    
    return key_terms

# Produktion: Mit Token | Test: Ohne Token (VISITOR Mode)
import requests

def convert_pdf(pdf_path, target_format, token=None):
    """
    target_format: 'word', 'powerpoint', 'pdfa', 'webp'
    """
    headers = {"Authorization": f"Bearer {token}"} if token else {}
    
    response = requests.post(
        "https://api.paperoffice.ai/latest/job",
        headers=headers,
        files={"file_1": open(pdf_path, "rb")},
        data={
            "target_format": target_format,
            "priority": 900
        }
    )
    
    return response.json()["job_result"]["output_url"]

# VISITOR Mode (kein Token)
word_url = convert_pdf("report.pdf", "word")

# Mit Token für Produktion
pdfa_url = convert_pdf("contract.pdf", "pdfa", "po_usr_...")

# Webhooks benötigen Token (für Account-Zuordnung)
from flask import Flask, request
import requests
import hmac
import hashlib

app = Flask(__name__)
WEBHOOK_SECRET = "your_webhook_secret"
TOKEN = "po_usr_YOUR_TOKEN"  # Token erforderlich für Webhooks

# 1. Webhook registrieren
def setup_webhook():
    requests.post(
        "https://api.paperoffice.ai/latest/webhooks",
        headers={"Authorization": f"Bearer {TOKEN}"},
        json={
            "url": "https://your-server.com/webhook",
            "events": ["job.completed", "job.failed"],
            "secret": WEBHOOK_SECRET
        }
    )

# 2. Webhook empfangen
@app.route("/webhook", methods=["POST"])
def handle_webhook():
    signature = request.headers.get("X-PaperOffice-Signature")
    expected = hmac.new(
        WEBHOOK_SECRET.encode(),
        request.data,
        hashlib.sha256
    ).hexdigest()
    
    if not hmac.compare_digest(signature, expected):
        return "Invalid signature", 401
    
    event = request.json
    if event["event"] == "job.completed":
        process_result(event["job_result"])
    
    return "OK", 200

# Produktion: Mit Token | Test: Ohne Token (VISITOR Mode)
import requests

def document_to_audio(pdf_path, voice="Nadja", token=None):
    headers = {"Authorization": f"Bearer {token}"} if token else {}
    
    # 1. OCR - Text extrahieren
    ocr_response = requests.post(
        "https://api.paperoffice.ai/latest/job",
        headers=headers,
        files={"file_1": open(pdf_path, "rb")},
        data={"ocr_mode": "complete", "priority": 900}
    )
    
    text = ocr_response.json()["job_result"]["text"]
    
    # 2. Text in Abschnitte teilen (max 5000 Zeichen)
    chunks = [text[i:i+5000] for i in range(0, len(text), 5000)]
    
    # 3. TTS für jeden Abschnitt
    audio_urls = []
    for chunk in chunks:
        tts_response = requests.post(
            "https://api.paperoffice.ai/latest/job",
            headers=headers,
            data={
                "text": chunk,
                "voice": voice,
                "output_format": "mp3",
                "output": "url",
                "priority": 999
            }
        )
        audio_urls.append(tts_response.json()["job_result"]["audio_url"])
    
    return audio_urls

# VISITOR Mode
urls = document_to_audio("handbuch.pdf")
print(f"Audio-Files: {len(urls)}")

# Produktion: Mit Token | Test: Ohne Token (VISITOR Mode)
import requests
import os
import csv
from pathlib import Path

def batch_ocr_to_csv(folder_path, output_csv, token=None):
    """
    Verarbeitet alle PDFs/Bilder in einem Ordner und exportiert nach CSV.
    """
    headers = {"Authorization": f"Bearer {token}"} if token else {}
    
    # Unterstützte Formate
    extensions = {'.pdf', '.png', '.jpg', '.jpeg', '.tiff', '.webp'}
    files = [f for f in Path(folder_path).iterdir() 
             if f.suffix.lower() in extensions]
    
    results = []
    
    for file_path in files:
        print(f"Verarbeite: {file_path.name}")
        
        # OCR Request
        response = requests.post(
            "https://api.paperoffice.ai/latest/job",
            headers=headers,
            files={"file_1": open(file_path, "rb")},
            data={
                "ocr_mode": "complete",
                "priority": 900
            }
        )
        
        result = response.json()["job_result"]
        
        results.append({
            "filename": file_path.name,
            "pages": result.get("page_count", 1),
            "text_length": len(result.get("text", "")),
            "text_preview": result.get("text", "")[:500],
            "confidence": result.get("confidence", 0)
        })
    
    # CSV Export
    with open(output_csv, 'w', newline='', encoding='utf-8') as f:
        writer = csv.DictWriter(f, fieldnames=results[0].keys())
        writer.writeheader()
        writer.writerows(results)
    
    print(f"✅ {len(results)} Dokumente → {output_csv}")
    return results

# VISITOR Mode - kein Token nötig!
batch_ocr_to_csv("./documents", "ocr_results.csv")

# Mit Token für Produktion
batch_ocr_to_csv("./documents", "results.csv", "po_usr_...")