Raise each VortexErrorKind as its Python exception class

The Python bindings turned every VortexError into RuntimeError, so none of
the kinds reached Python, where they were designed to mean something: a
caller could not catch an IndexError or a KeyError, because there was
never one to catch.

Each kind now raises the exception it is the analogue of:

  OutOfBounds      IndexError
  NotFound         KeyError
  Overflow         OverflowError
  InvalidArgument  ValueError
  Serde            ValueError
  MismatchedTypes  TypeError
  NotImplemented   NotImplementedError
  AssertionFailed  AssertionError
  Io               OSError
  Other            RuntimeError

The one test that asserted RuntimeError was checking that an unserializable
expression reports clearly; it now expects the NotImplementedError that
operation raises.

Signed-off-by: Robert Kruszewski <github@robertk.io>
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01S7EtMqoZ91rrCCh9vS2yTm

Author: robert3005

vortex-python/src/error.rs

@@ -3,8 +3,17 @@
 
 use pyo3::CastError;
 use pyo3::PyErr;
+use pyo3::exceptions::PyAssertionError;
+use pyo3::exceptions::PyIndexError;
+use pyo3::exceptions::PyKeyError;
+use pyo3::exceptions::PyNotImplementedError;
+use pyo3::exceptions::PyOSError;
+use pyo3::exceptions::PyOverflowError;
 use pyo3::exceptions::PyRuntimeError;
+use pyo3::exceptions::PyTypeError;
+use pyo3::exceptions::PyValueError;
 use vortex::error::VortexError;
+use vortex::error::VortexErrorKind;
 
 /// Error type to merge [`VortexError`] and [`PyErr`].
 pub enum PyVortexError {
@@ -37,7 +46,24 @@ impl From<PyVortexError> for PyErr {
     fn from(value: PyVortexError) -> Self {
         match value {
             PyVortexError::Py(py) => py,
-            PyVortexError::Vortex(vx) => PyRuntimeError::new_err(vx.to_string()),
+            PyVortexError::Vortex(vx) => vortex_to_py_err(vx),
         }
     }
 }
+
+/// Raises a [`VortexError`] as the Python exception its kind is the analogue of.
+fn vortex_to_py_err(error: VortexError) -> PyErr {
+    let message = error.to_string();
+    match error.kind() {
+        VortexErrorKind::OutOfBounds => PyIndexError::new_err(message),
+        VortexErrorKind::NotFound => PyKeyError::new_err(message),
+        VortexErrorKind::Overflow => PyOverflowError::new_err(message),
+        VortexErrorKind::InvalidArgument | VortexErrorKind::Serde => PyValueError::new_err(message),
+        VortexErrorKind::NotImplemented => PyNotImplementedError::new_err(message),
+        VortexErrorKind::MismatchedTypes => PyTypeError::new_err(message),
+        VortexErrorKind::AssertionFailed => PyAssertionError::new_err(message),
+        VortexErrorKind::Io => PyOSError::new_err(message),
+        // `Other`, and any kind added after this binding was written.
+        _ => PyRuntimeError::new_err(message),
+    }
+}

vortex-python/test/test_expr.py

@@ -115,7 +115,7 @@ def test_builder_round_trips_through_proto(name: str) -> None:
 
 @pytest.mark.parametrize("name", sorted(NOT_SERIALIZABLE))
 def test_unserializable_builder_reports_clearly(name: str) -> None:
-    with pytest.raises(RuntimeError, match="serial"):
+    with pytest.raises(NotImplementedError, match="serial"):
         _ = BUILDERS[name]().serialize()