Vendor qroissant 0.3.0 baseline

crates/qroissant-python/src/errors.rs

@@ -0,0 +1,114 @@
+use pyo3::create_exception;
+use pyo3::exceptions::PyException;
+use pyo3::exceptions::PyNotImplementedError;
+use pyo3::prelude::*;
+use pyo3::types::PyModule;
+use qroissant_transport::TransportError;
+use thiserror::Error;
+
+create_exception!(
+    qroissant,
+    QroissantError,
+    PyException,
+    "Base exception for qroissant errors."
+);
+create_exception!(
+    qroissant,
+    DecodeError,
+    QroissantError,
+    "Raised when q IPC payload decoding fails."
+);
+create_exception!(
+    qroissant,
+    ProtocolError,
+    QroissantError,
+    "Raised when q IPC framing or protocol validation fails."
+);
+create_exception!(
+    qroissant,
+    TransportErrorPy,
+    QroissantError,
+    "Raised when transport IO or socket operations fail."
+);
+create_exception!(
+    qroissant,
+    OperationError,
+    QroissantError,
+    "Raised when an operation is unsupported in the current state."
+);
+create_exception!(
+    qroissant,
+    QRuntimeError,
+    QroissantError,
+    "Raised when the remote q process returns an error response."
+);
+create_exception!(
+    qroissant,
+    PoolError,
+    QroissantError,
+    "Raised when connection pool management fails."
+);
+create_exception!(
+    qroissant,
+    PoolClosedError,
+    PoolError,
+    "Raised when a closed pool is used."
+);
+
+#[derive(Debug, Error)]
+pub enum PythonError {
+    #[error("{0}")]
+    Decode(String),
+    #[error("{0}")]
+    Protocol(String),
+    #[error("{0}")]
+    Transport(String),
+    #[error("{0}")]
+    Operation(String),
+    #[error("{0}")]
+    QRuntime(String),
+    #[error("{0}")]
+    Pool(String),
+    #[error("connection pool is closed")]
+    PoolClosed,
+    #[error("{0}")]
+    NotImplemented(String),
+}
+
+pub type PythonResult<T> = Result<T, PythonError>;
+
+pub fn register(module: &Bound<'_, PyModule>) -> PyResult<()> {
+    let py = module.py();
+    module.add("QroissantError", py.get_type::<QroissantError>())?;
+    module.add("DecodeError", py.get_type::<DecodeError>())?;
+    module.add("ProtocolError", py.get_type::<ProtocolError>())?;
+    module.add("TransportError", py.get_type::<TransportErrorPy>())?;
+    module.add("OperationError", py.get_type::<OperationError>())?;
+    module.add("QRuntimeError", py.get_type::<QRuntimeError>())?;
+    module.add("PoolError", py.get_type::<PoolError>())?;
+    module.add("PoolClosedError", py.get_type::<PoolClosedError>())?;
+    Ok(())
+}
+
+pub fn to_py_err(error: PythonError) -> PyErr {
+    match error {
+        PythonError::Decode(message) => DecodeError::new_err(message),
+        PythonError::Protocol(message) => ProtocolError::new_err(message),
+        PythonError::Transport(message) => TransportErrorPy::new_err(message),
+        PythonError::Operation(message) => OperationError::new_err(message),
+        PythonError::QRuntime(message) => QRuntimeError::new_err(message),
+        PythonError::Pool(message) => PoolError::new_err(message),
+        PythonError::PoolClosed => PoolClosedError::new_err("connection pool is closed"),
+        PythonError::NotImplemented(message) => PyNotImplementedError::new_err(message),
+    }
+}
+
+pub fn map_transport_error(error: TransportError) -> PythonError {
+    match error {
+        TransportError::Closed => PythonError::Operation(error.to_string()),
+        TransportError::Protocol(_) => PythonError::Protocol(error.to_string()),
+        TransportError::Io(_)
+        | TransportError::InvalidEndpoint(_)
+        | TransportError::InvalidQueryLength(_) => PythonError::Transport(error.to_string()),
+    }
+}