fix(hiroz-py): stop boxing anyhow errors before timeout classification

Converting anyhow::Error into Box<dyn Error> wraps the value, so
is_timeout's downcast no longer sees the real error and every service
timeout was misreported as a plain HirozError -- caught by
test_p5_call_timeout_raises_timeout_error.

Split into map_call_error (anyhow, derefs) and map_zenoh_error (the
action paths' Box<dyn Error>), sharing the classify/format helpers.

Author: YuanYuYuan

crates/hiroz-py/src/action.rs

@@ -192,7 +192,7 @@ impl PyZActionClient {
                             "send_goal timed out: no action server responded",
                         )
                     })?
-                    .map_err(crate::error::map_call_error)
+                    .map_err(crate::error::map_zenoh_error)
             })
         })?;
 
@@ -360,14 +360,14 @@ impl PyZClientGoalHandle {
                                 "Action result not received within {t:?}"
                             )))
                         }
-                        Err(e) => Err(crate::error::map_call_error(e)),
+                        Err(e) => Err(crate::error::map_zenoh_error(e)),
                     }
                 } else {
                     handle
                         .result()
                         .await
                         .map(|msg| msg.0)
-                        .map_err(crate::error::map_call_error)
+                        .map_err(crate::error::map_zenoh_error)
                 }
             })
         })?;

crates/hiroz-py/src/error.rs

@@ -10,7 +10,7 @@ pyo3::create_exception!(hiroz_py, TypeMismatchError, HirozError);
 
 /// Render an error and its full source chain as `outer: inner: root`.
 ///
-/// Matches anyhow's `{:#}` output, which we lose once the error is boxed.
+/// Matches anyhow's `{:#}` output, which a bare `Box<dyn Error>` does not give us.
 fn format_chain(err: &(dyn std::error::Error + 'static)) -> String {
     let mut msg = err.to_string();
     let mut source = err.source();
@@ -21,31 +21,36 @@ fn format_chain(err: &(dyn std::error::Error + 'static)) -> String {
     msg
 }
 
-/// Map a core error to the right Python exception.
-///
-/// Timeout-shaped errors become `hiroz_py.TimeoutError`; everything else
-/// becomes `hiroz_py.HirozError`. Use this for blocking calls that raise on
-/// failure (e.g. `ZClient.call`, `send_goal`, `get_result`). Methods whose
-/// documented contract is to return `None` on timeout should keep doing so
-/// rather than calling this.
-///
-/// Generic over the error type because the service path yields `anyhow::Error`
-/// while the action path yields `zenoh::Error`; both classify identically via
-/// the core's structured detector, which walks the whole source chain — do not
-/// string-match on the message.
-pub(crate) fn map_call_error<E>(e: E) -> PyErr
-where
-    E: Into<Box<dyn std::error::Error + Send + Sync + 'static>>,
-{
-    let err = e.into();
-    let msg = format_chain(&*err);
-    if hiroz::error::is_timeout(&*err) {
+fn classify(is_timeout: bool, msg: String) -> PyErr {
+    if is_timeout {
         TimeoutError::new_err(msg)
     } else {
         HirozError::new_err(msg)
     }
 }
 
+/// Map an `anyhow` error to the right Python exception.
+///
+/// Timeout-shaped errors become `hiroz_py.TimeoutError`; everything else
+/// becomes `hiroz_py.HirozError`. Use this for blocking calls that raise on
+/// failure (e.g. `ZClient.call`). Methods whose documented contract is to
+/// return `None` on timeout should keep doing so rather than calling this.
+///
+/// Classification goes through the core's structured detector, which walks the
+/// whole source chain — do not string-match on the message.
+pub(crate) fn map_call_error(e: anyhow::Error) -> PyErr {
+    // Deref rather than boxing: `Box<dyn Error>::from(anyhow::Error)` wraps the
+    // value so `is_timeout`'s downcast no longer sees the real error and every
+    // timeout is misreported as a plain HirozError.
+    classify(hiroz::error::is_timeout(&*e), format!("{e:#}"))
+}
+
+/// Same mapping for the action paths, which yield `zenoh::Error`
+/// (`Box<dyn Error + Send + Sync>`) rather than `anyhow::Error`.
+pub(crate) fn map_zenoh_error(e: zenoh::Error) -> PyErr {
+    classify(hiroz::error::is_timeout(&*e), format_chain(&*e))
+}
+
 /// Trait for converting Rust errors to Python exceptions
 pub(crate) trait IntoPyErr {
     fn into_pyerr(self) -> PyErr;