refactor(rust): Remove thiserror dependency (#20979)

Author: orlp

Cargo.lock

@@ -80,7 +80,6 @@ streaming-iterator = "0.1.9"
 strength_reduce = "0.2"
 strum = "0.26"
 strum_macros = "0.26"
-thiserror = "2"
 tokio = "1.26"
 tokio-util = "0.7.8"
 unicode-normalization = "0.1.24"

Cargo.toml

@@ -38,7 +38,6 @@ regex = { workspace = true, optional = true }
 serde = { workspace = true, optional = true }
 serde_json = { workspace = true, optional = true }
 strum_macros = { workspace = true }
-thiserror = { workspace = true }
 xxhash-rust = { workspace = true }
 
 [dev-dependencies]

crates/polars-core/Cargo.toml

@@ -14,7 +14,6 @@ avro-schema = { workspace = true, optional = true }
 object_store = { workspace = true, optional = true }
 regex = { workspace = true, optional = true }
 simdutf8 = { workspace = true }
-thiserror = { workspace = true }
 
 [target.'cfg(not(target_family = "wasm"))'.dependencies]
 signal-hook = "0.3"

crates/polars-error/Cargo.toml

@@ -75,49 +75,60 @@ impl Display for ErrString {
     }
 }
 
-#[derive(Debug, Clone, thiserror::Error)]
+#[derive(Debug, Clone)]
 pub enum PolarsError {
-    #[error("not found: {0}")]
     ColumnNotFound(ErrString),
-    #[error("{0}")]
     ComputeError(ErrString),
-    #[error("duplicate: {0}")]
     Duplicate(ErrString),
-    #[error("{0}")]
     InvalidOperation(ErrString),
-    #[error("{}", match msg {
-        Some(msg) => format!("{}", msg),
-        None => format!("{}", error)
-    })]
     IO {
         error: Arc<io::Error>,
         msg: Option<ErrString>,
     },
-    #[error("no data: {0}")]
     NoData(ErrString),
-    #[error("{0}")]
     OutOfBounds(ErrString),
-    #[error("field not found: {0}")]
     SchemaFieldNotFound(ErrString),
-    #[error("{0}")]
     SchemaMismatch(ErrString),
-    #[error("lengths don't match: {0}")]
     ShapeMismatch(ErrString),
-    #[error("{0}")]
     SQLInterface(ErrString),
-    #[error("{0}")]
     SQLSyntax(ErrString),
-    #[error("string caches don't match: {0}")]
     StringCacheMismatch(ErrString),
-    #[error("field not found: {0}")]
     StructFieldNotFound(ErrString),
-    #[error("{error}: {msg}")]
     Context {
         error: Box<PolarsError>,
         msg: ErrString,
     },
 }
 
+impl Error for PolarsError {}
+
+impl Display for PolarsError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        use PolarsError::*;
+        match self {
+            ComputeError(msg)
+            | InvalidOperation(msg)
+            | OutOfBounds(msg)
+            | SchemaMismatch(msg)
+            | SQLInterface(msg)
+            | SQLSyntax(msg) => write!(f, "{msg}"),
+
+            ColumnNotFound(msg) => write!(f, "not found: {msg}"),
+            Duplicate(msg) => write!(f, "duplicate: {msg}"),
+            IO { error, msg } => match msg {
+                Some(m) => write!(f, "{m}"),
+                None => write!(f, "{error}"),
+            },
+            NoData(msg) => write!(f, "no data: {msg}"),
+            SchemaFieldNotFound(msg) => write!(f, "field not found: {msg}"),
+            ShapeMismatch(msg) => write!(f, "lengths don't match: {msg}"),
+            StringCacheMismatch(msg) => write!(f, "string caches don't match: {msg}"),
+            StructFieldNotFound(msg) => write!(f, "field not found: {msg}"),
+            Context { error, msg } => write!(f, "{error}: {msg}"),
+        }
+    }
+}
+
 impl From<io::Error> for PolarsError {
     fn from(value: io::Error) -> Self {
         PolarsError::IO {

crates/polars-error/src/lib.rs

@@ -46,7 +46,6 @@ pyo3 = { workspace = true, features = ["abi3-py39", "chrono", "chrono-tz", "mult
 rayon = { workspace = true }
 recursive = { workspace = true }
 serde_json = { workspace = true, optional = true }
-thiserror = { workspace = true }
 
 [dependencies.polars]
 workspace = true

crates/polars-python/Cargo.toml

@@ -1,5 +1,6 @@
-use std::fmt::{Debug, Formatter};
-use std::io::{Error, ErrorKind};
+use std::error::Error;
+use std::fmt::{Debug, Display, Formatter};
+use std::io::{Error as IoError, ErrorKind};
 
 use polars::prelude::PolarsError;
 use polars_error::PolarsWarning;
@@ -9,7 +10,6 @@ use pyo3::exceptions::{
 };
 use pyo3::prelude::*;
 use pyo3::PyTypeInfo;
-use thiserror::Error;
 
 use crate::exceptions::{
     CategoricalRemappingWarning, ColumnNotFoundError, ComputeError, DuplicateError,
@@ -19,23 +19,51 @@ use crate::exceptions::{
 };
 use crate::Wrap;
 
-#[derive(Error)]
 pub enum PyPolarsErr {
-    #[error(transparent)]
-    Polars(#[from] PolarsError),
-    #[error(transparent)]
-    Python(#[from] PyErr),
-    #[error("{0}")]
+    Polars(PolarsError),
+    Python(PyErr),
     Other(String),
 }
 
-impl std::convert::From<std::io::Error> for PyPolarsErr {
-    fn from(value: Error) -> Self {
-        PyPolarsErr::Other(format!("{value:?}"))
+impl Error for PyPolarsErr {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match self {
+            Self::Polars(err) => Some(err),
+            Self::Python(err) => Some(err),
+            Self::Other(_) => None,
+        }
+    }
+}
+
+impl std::fmt::Display for PyPolarsErr {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Polars(err) => Display::fmt(err, f),
+            Self::Python(err) => Display::fmt(err, f),
+            Self::Other(err) => write!(f, "{err}"),
+        }
+    }
+}
+
+impl From<PolarsError> for PyPolarsErr {
+    fn from(err: PolarsError) -> Self {
+        PyPolarsErr::Polars(err)
+    }
+}
+
+impl From<PyErr> for PyPolarsErr {
+    fn from(err: PyErr) -> Self {
+        PyPolarsErr::Python(err)
+    }
+}
+
+impl From<IoError> for PyPolarsErr {
+    fn from(err: IoError) -> Self {
+        PyPolarsErr::Other(format!("{err:?}"))
     }
 }
 
-impl std::convert::From<PyPolarsErr> for PyErr {
+impl From<PyPolarsErr> for PyErr {
     fn from(err: PyPolarsErr) -> PyErr {
         use PyPolarsErr::*;
         match err {