Register custom exceptions for Python bindings

Author: gemenerik

cflib2/__init__.py

@@ -29,6 +29,22 @@
     NoTocCache,
     InMemoryTocCache,
     FileTocCache,
+    # Exceptions
+    CrazyflieError,
+    ProtocolVersionNotSupportedError,
+    ProtocolError,
+    ParamError,
+    LogError,
+    ConversionError,
+    LinkError,
+    DisconnectedError,
+    VariableNotFoundError,
+    SystemError,
+    AppchannelPacketTooLargeError,
+    InvalidArgumentError,
+    TimeoutError,
+    MemoryError,
+    InvalidParameterError,
 )
 
 __all__ = [
@@ -37,4 +53,20 @@
     "NoTocCache",
     "InMemoryTocCache",
     "FileTocCache",
+    # Exceptions
+    "CrazyflieError",
+    "ProtocolVersionNotSupportedError",
+    "ProtocolError",
+    "ParamError",
+    "LogError",
+    "ConversionError",
+    "LinkError",
+    "DisconnectedError",
+    "VariableNotFoundError",
+    "SystemError",
+    "AppchannelPacketTooLargeError",
+    "InvalidArgumentError",
+    "TimeoutError",
+    "MemoryError",
+    "InvalidParameterError",
 ]

rust/src/error.rs

@@ -4,7 +4,7 @@
 // | / ,--'  |    / /_/ / / /_/ /__/ /  / /_/ / / /_/  __/
 //    +------`   /_____/_/\__/\___/_/   \__,_/ /___/\___/
 //
-// Copyright (C) 2025 Bitcraze AB
+// Copyright (C) 2026 Bitcraze AB
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -20,11 +20,68 @@
 // along with this program. If not, see <http://www.gnu.org/licenses/>.
 
 //! Error conversion utilities for Python bindings
+//!
+//! Each exception maps 1:1 to a variant of `crazyflie_lib::Error`.
 
-use pyo3::exceptions::PyRuntimeError;
-use pyo3::PyErr;
+use pyo3::create_exception;
+use pyo3::exceptions::PyException;
+use pyo3::prelude::*;
+
+create_exception!(cflib2._rust, CrazyflieError, PyException, "Base exception for all Crazyflie errors.");
+create_exception!(cflib2._rust, ProtocolVersionNotSupportedError, CrazyflieError, "Protocol version not supported.");
+create_exception!(cflib2._rust, ProtocolError, CrazyflieError, "Unexpected protocol error.");
+create_exception!(cflib2._rust, ParamError, CrazyflieError, "Parameter subsystem error.");
+create_exception!(cflib2._rust, LogError, CrazyflieError, "Log subsystem error.");
+create_exception!(cflib2._rust, ConversionError, CrazyflieError, "Value conversion error.");
+create_exception!(cflib2._rust, LinkError, CrazyflieError, "Crazyflie link error.");
+create_exception!(cflib2._rust, DisconnectedError, CrazyflieError, "Crazyflie is disconnected.");
+create_exception!(cflib2._rust, VariableNotFoundError, CrazyflieError, "Variable not found in TOC.");
+create_exception!(cflib2._rust, SystemError, CrazyflieError, "Async executor error.");
+create_exception!(cflib2._rust, AppchannelPacketTooLargeError, CrazyflieError, "App channel packet exceeds MTU.");
+create_exception!(cflib2._rust, InvalidArgumentError, CrazyflieError, "Invalid argument.");
+create_exception!(cflib2._rust, TimeoutError, CrazyflieError, "Operation timed out.");
+create_exception!(cflib2._rust, MemoryError, CrazyflieError, "Memory subsystem error.");
+create_exception!(cflib2._rust, InvalidParameterError, CrazyflieError, "Invalid parameter.");
+
+/// Register all custom exception types with the Python module
+pub fn register_exceptions(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    let py = m.py();
+    m.add("CrazyflieError", py.get_type::<CrazyflieError>())?;
+    m.add("ProtocolVersionNotSupportedError", py.get_type::<ProtocolVersionNotSupportedError>())?;
+    m.add("ProtocolError", py.get_type::<ProtocolError>())?;
+    m.add("ParamError", py.get_type::<ParamError>())?;
+    m.add("LogError", py.get_type::<LogError>())?;
+    m.add("ConversionError", py.get_type::<ConversionError>())?;
+    m.add("LinkError", py.get_type::<LinkError>())?;
+    m.add("DisconnectedError", py.get_type::<DisconnectedError>())?;
+    m.add("VariableNotFoundError", py.get_type::<VariableNotFoundError>())?;
+    m.add("SystemError", py.get_type::<SystemError>())?;
+    m.add("AppchannelPacketTooLargeError", py.get_type::<AppchannelPacketTooLargeError>())?;
+    m.add("InvalidArgumentError", py.get_type::<InvalidArgumentError>())?;
+    m.add("TimeoutError", py.get_type::<TimeoutError>())?;
+    m.add("MemoryError", py.get_type::<MemoryError>())?;
+    m.add("InvalidParameterError", py.get_type::<InvalidParameterError>())?;
+    Ok(())
+}
 
 /// Convert Rust crazyflie_lib errors to Python exceptions
 pub fn to_pyerr(err: crazyflie_lib::Error) -> PyErr {
-    PyRuntimeError::new_err(format!("Crazyflie error: {:?}", err))
+    use crazyflie_lib::Error::*;
+    let msg = err.to_string();
+    match err {
+        ProtocolVersionNotSupported { .. } => ProtocolVersionNotSupportedError::new_err(msg),
+        ProtocolError(_) => self::ProtocolError::new_err(msg),
+        ParamError(_) => self::ParamError::new_err(msg),
+        LogError(_) => self::LogError::new_err(msg),
+        ConversionError(_) => self::ConversionError::new_err(msg),
+        LinkError(_) => self::LinkError::new_err(msg),
+        Disconnected => DisconnectedError::new_err(msg),
+        VariableNotFound => VariableNotFoundError::new_err(msg),
+        SystemError(_) => self::SystemError::new_err(msg),
+        AppchannelPacketTooLarge => AppchannelPacketTooLargeError::new_err(msg),
+        InvalidArgument(_) => InvalidArgumentError::new_err(msg),
+        Timeout => self::TimeoutError::new_err(msg),
+        MemoryError(_) => self::MemoryError::new_err(msg),
+        InvalidParameter(_) => InvalidParameterError::new_err(msg),
+    }
 }

rust/src/lib.rs

@@ -72,6 +72,7 @@ fn _rust(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<NoTocCache>()?;
     m.add_class::<InMemoryTocCache>()?;
     m.add_class::<FileTocCache>()?;
+    error::register_exceptions(m)?;
     Ok(())
 }