Error Handling

{
  "detail": "Human-readable error message",
  "error": "error_code_identifier",
  "status_code": 400,
  "request_id": "req_unique_identifier"  // Optional, for debugging
}

from blindfold import Blindfold
from blindfold.exceptions import (
    BlindfoldAPIError,
    AuthenticationError,
    RateLimitError,
    ValidationError
)

client = Blindfold(api_key="your-api-key")

try:
    result = client.tokenize("Sample text with PII")
except AuthenticationError as e:
    print(f"Invalid API key: {e}")
    # Re-authenticate or use different key
except RateLimitError as e:
    print(f"Rate limit exceeded. Retry after {e.retry_after} seconds")
    # Implement backoff strategy
except ValidationError as e:
    print(f"Invalid input: {e}")
    # Fix request parameters
except BlindfoldAPIError as e:
    print(f"API error: {e.status_code} - {e.message}")
    # Handle general API errors

import { Blindfold } from '@blindfold/sdk';
import {
  AuthenticationError,
  RateLimitError,
  ValidationError,
  BlindfoldError
} from '@blindfold/sdk/errors';

const client = new Blindfold({ apiKey: 'your-api-key' });

try {
  const result = await client.tokenize("Sample text with PII");
} catch (error) {
  if (error instanceof AuthenticationError) {
    console.error('Invalid API key:', error.message);
    // Handle authentication error
  } else if (error instanceof RateLimitError) {
    console.error(`Rate limit exceeded. Retry after ${error.retryAfter}s`);
    // Implement exponential backoff
  } else if (error instanceof ValidationError) {
    console.error('Invalid input:', error.message);
    // Fix request parameters
  } else if (error instanceof BlindfoldError) {
    console.error('API error:', error.statusCode, error.message);
    // Handle general errors
  }
}

# Using curl with error handling
response=$(curl -s -w "\n%{http_code}" -X POST \
  https://api.blindfold.dev/api/public/v1/tokenize \
  -H "X-API-Key: your-api-key" \
  -H "Content-Type: application/json" \
  -d '{"text": "Sample text"}')

http_code=$(echo "$response" | tail -n1)
body=$(echo "$response" | head -n-1)

if [ "$http_code" -eq 200 ]; then
  echo "Success: $body"
elif [ "$http_code" -eq 401 ]; then
  echo "Authentication failed"
elif [ "$http_code" -eq 429 ]; then
  echo "Rate limit exceeded"
else
  echo "Error $http_code: $body"
fi

import time
from blindfold import Blindfold
from blindfold.exceptions import RateLimitError, BlindfoldAPIError

def tokenize_with_retry(text, max_retries=3):
    client = Blindfold(api_key="your-api-key")

    for attempt in range(max_retries):
        try:
            return client.tokenize(text)
        except RateLimitError as e:
            if attempt < max_retries - 1:
                wait_time = e.retry_after or (2 ** attempt)  # Exponential backoff
                print(f"Rate limited. Retrying in {wait_time}s...")
                time.sleep(wait_time)
            else:
                raise
        except BlindfoldAPIError as e:
            if e.status_code >= 500 and attempt < max_retries - 1:
                wait_time = 2 ** attempt
                print(f"Server error. Retrying in {wait_time}s...")
                time.sleep(wait_time)
            else:
                raise

async function tokenizeWithRetry(text, maxRetries = 3) {
  const client = new Blindfold({ apiKey: 'your-api-key' });

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await client.tokenize(text);
    } catch (error) {
      if (error instanceof RateLimitError && attempt < maxRetries - 1) {
        const waitTime = error.retryAfter || Math.pow(2, attempt) * 1000;
        console.log(`Rate limited. Retrying in ${waitTime}ms...`);
        await new Promise(resolve => setTimeout(resolve, waitTime));
      } else if (error.statusCode >= 500 && attempt < maxRetries - 1) {
        const waitTime = Math.pow(2, attempt) * 1000;
        console.log(`Server error. Retrying in ${waitTime}ms...`);
        await new Promise(resolve => setTimeout(resolve, waitTime));
      } else {
        throw error;
      }
    }
  }
}

# ❌ Wrong
client = Blindfold(api_key="")  # Empty API key
result = client.tokenize("text")  # 401 Unauthorized

# ✅ Correct
client = Blindfold(api_key="your-valid-api-key")
result = client.tokenize("text")

# ❌ Wrong
curl -X POST https://api.blindfold.dev/api/public/v1/tokenize \
  -H "X-API-Key: your-api-key" \
  -H "Content-Type: application/json" \
  -d '{}'  # Missing "text" field -> 400 Bad Request

# ✅ Correct
curl -X POST https://api.blindfold.dev/api/public/v1/tokenize \
  -H "X-API-Key: your-api-key" \
  -H "Content-Type: application/json" \
  -d '{"text": "Sample text"}'

# ❌ Wrong - No rate limit handling
for i in range(1000):
    client.tokenize(f"Text {i}")  # Will hit 429 after ~100 requests

# ✅ Correct - With retry logic
for i in range(1000):
    try:
        result = tokenize_with_retry(f"Text {i}")
    except RateLimitError:
        print("Rate limit exceeded even after retries")
        break