Exception Reference¶

from open_to_close.exceptions import AuthenticationError

try:
    client = OpenToCloseAPI(api_key="invalid_key")
    properties = client.properties.list_properties()
except AuthenticationError as e:
    print(f"Authentication failed: {e}")
    # Handle authentication error
    # - Check API key configuration
    # - Regenerate API key if needed
    # - Verify environment variables

import os

# Check if API key is set
api_key = os.getenv("OPEN_TO_CLOSE_API_KEY")
if not api_key:
    raise EnvironmentError("API key not found in environment")

# Check API key format (basic validation)
if len(api_key) < 50:
    print("Warning: API key seems too short")

def test_authentication():
    try:
        client = OpenToCloseAPI()
        # Simple test call
        client.agents.list_agents(params={"limit": 1})
        print("✅ Authentication successful")
        return True
    except AuthenticationError:
        print("❌ Authentication failed")
        return False

from open_to_close.exceptions import ValidationError

try:
    # Invalid data that fails validation
    client.properties.create_property({
        "invalid_field": "value",
        "price": "not_a_number"  # Should be numeric
    })
except ValidationError as e:
    print(f"Validation failed: {e}")
    # Handle validation error
    # - Check required fields
    # - Validate data types
    # - Review API documentation

def validate_property_data(property_data):
    """Validate property data before API call."""
    required_fields = ["address", "city", "state"]
    errors = []

    # Check required fields
    for field in required_fields:
        if field not in property_data:
            errors.append(f"Missing required field: {field}")

    # Validate data types
    if "price" in property_data:
        try:
            float(property_data["price"])
        except (ValueError, TypeError):
            errors.append("Price must be a number")

    if errors:
        raise ValidationError(f"Validation errors: {', '.join(errors)}")

    return True

# Usage
property_data = {"address": "123 Main St", "city": "NYC", "state": "NY"}
validate_property_data(property_data)
client.properties.create_property(property_data)

from open_to_close.exceptions import NotFoundError

try:
    # Attempting to access non-existent resource
    property_data = client.properties.retrieve_property(999999)
except NotFoundError as e:
    print(f"Property not found: {e}")
    # Handle not found error
    # - Verify resource ID
    # - Check if resource was deleted
    # - Provide user feedback

def safe_get_property(client, property_id):
    """Safely retrieve a property with error handling."""
    try:
        return client.properties.retrieve_property(property_id)
    except NotFoundError:
        print(f"Property {property_id} not found")
        return None
    except Exception as e:
        print(f"Error retrieving property {property_id}: {e}")
        return None

# Batch safe operations
def get_multiple_properties(client, property_ids):
    """Get multiple properties, skipping those that don't exist."""
    properties = []
    for prop_id in property_ids:
        prop = safe_get_property(client, prop_id)
        if prop:
            properties.append(prop)
    return properties

import time
from open_to_close.exceptions import RateLimitError

def rate_limited_operation(operation_func, max_retries=3):
    """Execute operation with automatic retry on rate limit."""
    for attempt in range(max_retries):
        try:
            return operation_func()
        except RateLimitError as e:
            if attempt < max_retries - 1:
                # Extract retry delay from headers if available
                delay = getattr(e, 'retry_after', 60)  # Default 60 seconds
                print(f"Rate limited. Waiting {delay} seconds before retry...")
                time.sleep(delay)
            else:
                print("Max retries exceeded for rate limit")
                raise

# Usage
def get_properties():
    return client.properties.list_properties()

properties = rate_limited_operation(get_properties)

import time

def process_properties_batch(client, property_ids, delay=1.0):
    """Process properties in batches with rate limiting."""
    results = []

    for i, prop_id in enumerate(property_ids):
        try:
            # Add delay between requests
            if i > 0:
                time.sleep(delay)

            property_data = client.properties.retrieve_property(prop_id)
            results.append(property_data)

        except RateLimitError:
            print(f"Rate limited at property {prop_id}. Increasing delay.")
            delay *= 2  # Exponential backoff
            time.sleep(delay)
            # Retry current item
            property_data = client.properties.retrieve_property(prop_id)
            results.append(property_data)

    return results

import time
from open_to_close.exceptions import ServerError

def retry_on_server_error(operation_func, max_retries=3, base_delay=5):
    """Retry operation on server errors with exponential backoff."""
    for attempt in range(max_retries):
        try:
            return operation_func()
        except ServerError as e:
            if attempt < max_retries - 1:
                delay = base_delay * (2 ** attempt)  # Exponential backoff
                print(f"Server error on attempt {attempt + 1}. Retrying in {delay}s...")
                time.sleep(delay)
            else:
                print("Max retries exceeded for server error")
                raise

import time
from open_to_close.exceptions import NetworkError

def handle_network_issues(operation_func, max_retries=3):
    """Handle network connectivity issues."""
    for attempt in range(max_retries):
        try:
            return operation_func()
        except NetworkError as e:
            if attempt < max_retries - 1:
                delay = 10 * (attempt + 1)  # Linear backoff for network issues
                print(f"Network error: {e}. Retrying in {delay}s...")
                time.sleep(delay)
            else:
                print("Network connectivity could not be established")
                raise