Exceptions

RaxeException (base)
├── ValidationError
├── AuthenticationError
├── ConfigurationError
├── RaxeBlockedError
├── RuleError
├── DatabaseError
└── NetworkError

from raxe.exceptions import (
    RaxeException,
    RaxeBlockedError,
    ValidationError,
    AuthenticationError,
    ConfigurationError,
    RuleError,
    DatabaseError,
    NetworkError,
)

class RaxeException(Exception):
    code: str        # Error code (e.g., "RAXE-AUTH-001")
    message: str     # Human-readable message

from raxe.exceptions import RaxeException

try:
    result = raxe.scan(prompt)
except RaxeException as e:
    print(f"Error [{e.code}]: {e.message}")

class RaxeBlockedError(RaxeException):
    scan_result: ScanResult  # The scan result that triggered blocking

from raxe import Raxe
from raxe.exceptions import RaxeBlockedError

raxe = Raxe()

try:
    # This will raise if threats detected and policy is BLOCK
    result = raxe.scan("Ignore all previous instructions")
except RaxeBlockedError as e:
    print(f"Request blocked!")
    print(f"Severity: {e.scan_result.highest_severity}")
    print(f"Detections: {e.scan_result.detection_count}")

    for detection in e.scan_result.detections:
        print(f"  - {detection.rule_id}: {detection.severity}")

# In a web application
@app.post("/chat")
async def chat(request: ChatRequest):
    try:
        result = raxe.scan(request.message)
        if result.is_safe:
            return await llm.complete(request.message)
    except RaxeBlockedError as e:
        return JSONResponse(
            status_code=400,
            content={
                "error": "Request blocked for security reasons",
                "severity": e.scan_result.highest_severity.name,
            }
        )

class ValidationError(RaxeException):
    field: str | None  # Field that failed validation

from raxe.exceptions import ValidationError

try:
    result = raxe.scan("")  # Empty prompt
except ValidationError as e:
    print(f"Validation failed: {e.message}")
    # Error [RAXE-SCAN-001]: Empty prompt

class AuthenticationError(RaxeException):
    pass

from raxe import Raxe
from raxe.exceptions import AuthenticationError

try:
    raxe = Raxe(api_key="invalid_key")
except AuthenticationError as e:
    print(f"Auth failed: {e.message}")
    # Error [RAXE-AUTH-001]: Invalid API key format

class ConfigurationError(RaxeException):
    config_path: str | None  # Path to config file if applicable

from raxe import Raxe
from raxe.exceptions import ConfigurationError

try:
    raxe = Raxe(config_path="/invalid/path/config.yaml")
except ConfigurationError as e:
    print(f"Config error: {e.message}")
    print(f"Path: {e.config_path}")

class RuleError(RaxeException):
    rule_id: str | None  # Rule that caused the error

from raxe.exceptions import RuleError

# When validating custom rules
try:
    raxe.validate_rule("custom-rule.yaml")
except RuleError as e:
    print(f"Rule error: {e.message}")
    print(f"Rule ID: {e.rule_id}")

class DatabaseError(RaxeException):
    pass

from raxe.exceptions import DatabaseError

try:
    stats = raxe.get_stats()
except DatabaseError as e:
    print(f"Database error: {e.message}")

class NetworkError(RaxeException):
    pass

from raxe.exceptions import NetworkError

try:
    raxe.validate_key_remote()
except NetworkError as e:
    print(f"Network error: {e.message}")
    # Fall back to offline mode

from raxe import Raxe
from raxe.exceptions import (
    RaxeException,
    RaxeBlockedError,
    ValidationError,
    AuthenticationError,
)

def safe_scan(prompt: str) -> dict:
    try:
        raxe = Raxe()
        result = raxe.scan(prompt)
        return {"safe": result.is_safe, "result": result}

    except RaxeBlockedError as e:
        return {
            "safe": False,
            "blocked": True,
            "severity": e.scan_result.highest_severity.name,
        }

    except ValidationError as e:
        return {
            "error": "Invalid input",
            "code": e.code,
            "message": e.message,
        }

    except AuthenticationError as e:
        return {
            "error": "Authentication failed",
            "code": e.code,
            "message": e.message,
        }

    except RaxeException as e:
        # Catch-all for other RAXE errors
        return {
            "error": "RAXE error",
            "code": e.code,
            "message": e.message,
        }

from fastapi import FastAPI, HTTPException
from raxe import Raxe
from raxe.exceptions import RaxeBlockedError, ValidationError

app = FastAPI()
raxe = Raxe()

@app.post("/scan")
async def scan_endpoint(prompt: str):
    try:
        result = raxe.scan(prompt)
        return {
            "safe": result.is_safe,
            "detections": [d.rule_id for d in result.detections],
        }

    except RaxeBlockedError as e:
        raise HTTPException(
            status_code=400,
            detail={
                "error": "blocked",
                "severity": e.scan_result.highest_severity.name,
            }
        )

    except ValidationError as e:
        raise HTTPException(
            status_code=422,
            detail={"error": "validation", "message": str(e)}
        )

from raxe import AsyncRaxe
from raxe.exceptions import RaxeBlockedError

async def process_messages(messages: list[str]):
    results = []

    async with AsyncRaxe() as raxe:
        for message in messages:
            try:
                result = await raxe.scan(message)
                results.append({"message": message, "safe": result.is_safe})
            except RaxeBlockedError:
                results.append({"message": message, "safe": False, "blocked": True})

    return results