Error Classes

Exception handling with MontySyntaxError, MontyRuntimeError, and MontyTypingError

Overview

Monty provides three specialized error classes for different types of failures:

• MontySyntaxError - Syntax or parsing errors
• MontyRuntimeError - Runtime exceptions during execution
• MontyTypingError - Static type checking errors

All error classes inherit from MontyError, so you can catch any Monty exception with a single catch clause.

MontyError (Base Class)

Base class for all Monty interpreter errors.

Properties

message · string

The error message (includes exception type and message)

name · string

The error name: 'MontyError'

exception · ExceptionInfo

Information about the inner Python exception

Show ExceptionInfo properties

typeName · string

The Python exception type (e.g., 'ValueError', 'SyntaxError')

message · string

The exception message

Methods

display()

display(format?: 'type-msg' | 'msg'): string

Returns formatted exception string.

format · 'type-msg' | 'msg'

• 'msg' - Just the message (default)
• 'type-msg' - Format as 'ExceptionType: message'

output · string

Formatted exception string

Example

import { Monty, MontyError } from '@pydantic/monty'

try {
  const m = new Monty('invalid code')
} catch (error) {
  if (error instanceof MontyError) {
    console.log('Exception type:', error.exception.typeName)
    console.log('Message:', error.display('msg'))
    console.log('Full:', error.display('type-msg'))
  }
}

MontySyntaxError

Raised when Python code has syntax errors or cannot be parsed.

Inherits all properties and methods from MontyError.

Properties

name · string

'MontySyntaxError'

The inner exception typeName is always 'SyntaxError'.

Example

import { Monty, MontySyntaxError } from '@pydantic/monty'

try {
  const m = new Monty('def')
} catch (error) {
  if (error instanceof MontySyntaxError) {
    console.log('Syntax error:', error.message)
    console.log('Details:', error.display('type-msg'))
  }
}

Common Syntax Errors

// Incomplete function definition
const m1 = new Monty('def foo') // MontySyntaxError

// Invalid syntax
const m2 = new Monty('x = =') // MontySyntaxError

// Unclosed string
const m3 = new Monty('"hello') // MontySyntaxError

MontyRuntimeError

Raised when Monty code fails during execution. Provides access to the traceback and formatted error output.

Inherits all properties and methods from MontyError.

Properties

name · string

'MontyRuntimeError'

Methods

traceback()

traceback(): Frame[]

Returns the Monty traceback as an array of stack frames.

frames · Frame[]

Array of stack frames where the error occurred

Show Frame properties

filename · string

The filename where the code is located

line · number

Line number (1-based)

column · number

Column number (1-based)

endLine · number

End line number (1-based)

endColumn · number

End column number (1-based)

functionName · string | null

The function name, or null for module-level code

sourceLine · string | null

The source code line for preview

display()

display(format?: 'traceback' | 'type-msg' | 'msg'): string

Returns formatted exception string.

format · 'traceback' | 'type-msg' | 'msg'

• 'traceback' - Full traceback with stack frames (default)
• 'type-msg' - Format as 'ExceptionType: message'
• 'msg' - Just the message

output · string

Formatted exception string

Example: Basic Error Handling

import { Monty, MontyRuntimeError } from '@pydantic/monty'

try {
  const m = new Monty('1 / 0')
  m.run()
} catch (error) {
  if (error instanceof MontyRuntimeError) {
    console.log('Runtime error:', error.message)
    console.log('\nTraceback:')
    console.log(error.display('traceback'))
  }
}

Example: Inspecting Stack Frames

import { Monty, MontyRuntimeError } from '@pydantic/monty'

const code = `
def divide(a, b):
    return a / b

def calculate():
    return divide(10, 0)

calculate()
`

try {
  const m = new Monty(code)
  m.run()
} catch (error) {
  if (error instanceof MontyRuntimeError) {
    const frames = error.traceback()
    frames.forEach(frame => {
      console.log(`  File "${frame.filename}", line ${frame.line}, in ${frame.functionName || '<module>'}`)  
      if (frame.sourceLine) {
        console.log(`    ${frame.sourceLine}`)
      }
    })
  }
}

Common Runtime Errors

// Division by zero
const m1 = new Monty('1 / 0')
m1.run() // MontyRuntimeError: ZeroDivisionError

// Name not defined
const m2 = new Monty('x + 1')
m2.run() // MontyRuntimeError: NameError

// Type error
const m3 = new Monty('"hello" - 5')
m3.run() // MontyRuntimeError: TypeError

// Index error
const m4 = new Monty('[1, 2, 3][10]')
m4.run() // MontyRuntimeError: IndexError

MontyTypingError

Raised when static type checking finds errors in the code.

Inherits all properties and methods from MontyError.

Properties

name · string

'MontyTypingError'

The inner exception typeName is always 'TypeError'.

Methods

displayDiagnostics()

displayDiagnostics(format?: TypingDisplayFormat, color?: boolean): string

Renders rich type error diagnostics for tooling integration.

format · TypingDisplayFormat

Output format (default: 'full')

Options:

• 'full' - Full diagnostic output with context
• 'concise' - Concise single-line output
• 'json' - JSON format
• 'jsonlines' - JSON Lines format
• 'github' - GitHub Actions format
• 'gitlab' - GitLab CI format
• 'azure' - Azure DevOps format
• 'pylint' - Pylint format
• 'rdjson' - Reviewdog JSON format

color · boolean

Include ANSI color codes (default: false)

output · string

Formatted diagnostic output

Example: Type Checking

import { Monty, MontyTypingError } from '@pydantic/monty'

const code = `
def add(a: int, b: int) -> int:
    return a + b

result: str = add(1, 2)  # Type error: int assigned to str
`

try {
  const m = new Monty(code, { typeCheck: true })
} catch (error) {
  if (error instanceof MontyTypingError) {
    console.log('Type error found:')
    console.log(error.displayDiagnostics('full', false))
  }
}

Example: Manual Type Checking

import { Monty, MontyTypingError } from '@pydantic/monty'

const m = new Monty('"hello" + 1')

try {
  m.typeCheck()
} catch (error) {
  if (error instanceof MontyTypingError) {
    // Display concise format for CLI
    console.log(error.displayDiagnostics('concise'))
    
    // Or get JSON for tooling
    const diagnostics = error.displayDiagnostics('json')
    console.log(JSON.parse(diagnostics))
  }
}

Example: Different Output Formats

const m = new Monty('x: int = "hello"')

try {
  m.typeCheck()
} catch (error) {
  if (error instanceof MontyTypingError) {
    // Full format with colors (for terminal)
    console.log(error.displayDiagnostics('full', true))
    
    // GitHub Actions format (for CI)
    console.log(error.displayDiagnostics('github'))
    
    // JSON format (for programmatic use)
    const json = error.displayDiagnostics('json')
    const parsed = JSON.parse(json)
  }
}

Catching All Monty Errors

import { Monty, MontyError, MontySyntaxError, MontyRuntimeError, MontyTypingError } from '@pydantic/monty'

try {
  const m = new Monty(code, { typeCheck: true })
  const result = m.run({ inputs })
} catch (error) {
  if (error instanceof MontySyntaxError) {
    console.error('Syntax error:', error.display())
  } else if (error instanceof MontyTypingError) {
    console.error('Type error:')
    console.error(error.displayDiagnostics('concise'))
  } else if (error instanceof MontyRuntimeError) {
    console.error('Runtime error:')
    console.error(error.display('traceback'))
  } else if (error instanceof MontyError) {
    console.error('Unknown Monty error:', error.message)
  } else {
    throw error // Not a Monty error
  }
}

Error Type Hierarchy

Error (JavaScript built-in)
 └── MontyError
      ├── MontySyntaxError
      ├── MontyRuntimeError
      └── MontyTypingError

All Monty errors inherit from MontyError, which inherits from JavaScript’s built-in Error class.

See Also

• Monty Class - Main interpreter class
• Resource Limits - Prevent resource exhaustion errors