Exceptions Reference

Exception
└── PlexeError
    ├── SpecificationError
    │   ├── InsufficientSpecificationError
    │   ├── AmbiguousSpecificationError
    │   └── InvalidSchemaError
    ├── InstructionError
    ├── ConstraintError
    └── PlexeRuntimeError (also inherits from RuntimeError)
        └── CodeExecutionError

class PlexeError(Exception):
    """Base class for all Plexe-specific exceptions."""
    pass

class SpecificationError(PlexeError):
    """Base class for errors related to model specification."""
    pass

class InsufficientSpecificationError(SpecificationError):
    """Raised when the natural language specification is insufficiently detailed."""
    pass

# Intent too vague
raise InsufficientSpecificationError("Intent 'analyze data' is too vague. Please provide more specific details about the task.")

class AmbiguousSpecificationError(SpecificationError):
    """Raised when the natural language specification is ambiguous or contradictory."""
    pass

# Contradictory intent
raise AmbiguousSpecificationError("Intent contains contradictory requirements: maximize both precision and recall.")

class InvalidSchemaError(SpecificationError):
    """Raised when the input or output schema is invalid."""
    pass

# Invalid schema type
raise InvalidSchemaError("Schema must be a dictionary or a Pydantic model.")

# Missing required fields
raise InvalidSchemaError("Required field 'id' missing from input schema.")

class InstructionError(PlexeError):
    """Base class for errors related to instructions provided for model building."""
    pass

# Invalid instruction
raise InstructionError("Unable to interpret instruction for model building.")

class ConstraintError(PlexeError):
    """Base class for errors related to constraints."""
    pass

# Constraint violation
raise ConstraintError("Model output violates constraint: price must be positive.")

class PlexeRuntimeError(PlexeError, RuntimeError):
    """Base class for runtime errors during model execution or training."""
    pass

class CodeExecutionError(PlexeRuntimeError):
    """Raised when code execution fails for reasons other than timeout."""
    pass

# Syntax error
raise CodeExecutionError("Syntax error in generated code: Missing colon after parameters")

# Runtime error
raise CodeExecutionError("Runtime error while executing training code: shapes (60,1) and (50,1) not aligned")

import plexe
from plexe.exceptions import PlexeError, CodeExecutionError

try:
    model = plexe.Model(intent="Predict customer churn")
    model.build(datasets=[df])
except CodeExecutionError as e:
    print(f"Error executing generated code: {e}")
except PlexeError as e:
    print(f"Plexe error: {e}")
except Exception as e:
    print(f"Unexpected error: {e}")

import plexe
from plexe.exceptions import (
    SpecificationError,
    InvalidSchemaError,
    CodeExecutionError,
    PlexeRuntimeError
)

try:
    model = plexe.Model(intent="Predict customer churn")
    model.build(datasets=[df])
except InvalidSchemaError as e:
    print(f"Schema error: {e}")
    # Handle schema issues
except CodeExecutionError as e:
    print(f"Code execution error: {e}")
    # Handle generated code issues
except SpecificationError as e:
    print(f"Specification error: {e}")
    # Handle specification issues
except PlexeRuntimeError as e:
    print(f"Runtime error: {e}")
    # Handle runtime issues

import plexe
from plexe.exceptions import PlexeError, PlexeRuntimeError

try:
    prediction = model.predict(input_data)
except PlexeRuntimeError as e:
    print(f"Runtime error during prediction: {e}")
except PlexeError as e:
    print(f"Error during prediction: {e}")