use std::collections::HashMap;
use burn::prelude::TensorData;
use crate::errors::{
BunsenError,
BunsenResult,
};
pub type EventDataView<'a> = HashMap<&'a str, Vec<&'a TensorData>>;
pub fn assert_exact_data_keys(
target: &str,
view: &EventDataView<'_>,
keys: &[&str],
) -> BunsenResult<()> {
let mut unexpected: Vec<&str> = view
.keys()
.copied()
.filter(|key| !keys.contains(key))
.collect();
if unexpected.is_empty() {
return Ok(());
}
unexpected.sort_unstable();
Err(BunsenError::Invalid(format!(
"in `{target}`: unexpected event data keys {unexpected:?}; \
pattern declares {keys:?}"
)))
}
fn arity_error(
target: &str,
key: &str,
expected: &str,
actual: usize,
) -> BunsenError {
BunsenError::Invalid(format!(
"in `{target}`: event data key `{key}` has {actual} values, expected {expected}"
))
}
fn get_values<'v, 'x>(
target: &str,
view: &'v EventDataView<'x>,
key: &str,
) -> BunsenResult<&'v [&'x TensorData]> {
match view.get(key) {
Some(values) => Ok(values),
None => {
let mut present: Vec<&str> = view.keys().copied().collect();
present.sort_unstable();
Err(BunsenError::Invalid(format!(
"in `{target}`: missing event data key `{key}`; present keys {present:?}"
)))
}
}
}
pub fn take_one<'x>(
target: &str,
view: &EventDataView<'x>,
key: &str,
) -> BunsenResult<&'x TensorData> {
let values = get_values(target, view, key)?;
match values {
[value] => Ok(value),
_ => Err(arity_error(target, key, "1", values.len())),
}
}
pub fn take_fixed<'x, const K: usize>(
target: &str,
view: &EventDataView<'x>,
key: &str,
) -> BunsenResult<[&'x TensorData; K]> {
let values = get_values(target, view, key)?;
<[&'x TensorData; K]>::try_from(values)
.map_err(|_| arity_error(target, key, &K.to_string(), values.len()))
}
pub fn take_any<'x>(
target: &str,
view: &EventDataView<'x>,
key: &str,
) -> BunsenResult<Vec<&'x TensorData>> {
Ok(get_values(target, view, key)?.to_vec())
}
pub use crate::__unpack_audit_probe_event_data as unpack_audit_probe_event_data;
#[doc(hidden)]
#[macro_export]
macro_rules! __unpack_audit_probe_event_data {
([$($target:expr),+ $(,)?], { $($name:ident $(: $arity:tt)?),+ $(,)? } $(,)?) => {{
#[allow(dead_code)]
#[derive(Debug)]
struct Unpacked<'x> {
$($name: $crate::__unpack_audit_probe_event_data!(@ty 'x, $($arity)?),)+
}
fn unpack_one<'x, V>(
target: &str,
event: &'x V,
) -> $crate::errors::BunsenResult<Unpacked<'x>>
where
V: $crate::burner::testing::audit::AuditProbeEventView,
{
let view = $crate::burner::testing::audit::AuditProbeEventView::data_map_view(event);
$crate::burner::testing::audit::assert_exact_data_keys(
target,
&view,
&[$(::core::stringify!($name)),+],
)?;
Ok(Unpacked {
$($name: $crate::__unpack_audit_probe_event_data!(
@take target, &view, ::core::stringify!($name), $($arity)?
)?,)+
})
}
(|| ::core::result::Result::Ok::<_, $crate::errors::BunsenError>([
$(unpack_one(::core::stringify!($target), $target)?,)+
]))()
}};
(@ty $lt:lifetime,) => { &$lt ::burn::prelude::TensorData };
(@ty $lt:lifetime, [..]) => { ::std::vec::Vec<&$lt ::burn::prelude::TensorData> };
(@ty $lt:lifetime, [$n:literal]) => { [&$lt ::burn::prelude::TensorData; $n] };
(@take $target:expr, $view:expr, $key:expr,) => {
$crate::burner::testing::audit::take_one($target, $view, $key)
};
(@take $target:expr, $view:expr, $key:expr, [..]) => {
$crate::burner::testing::audit::take_any($target, $view, $key)
};
(@take $target:expr, $view:expr, $key:expr, [$n:literal]) => {
$crate::burner::testing::audit::take_fixed::<$n>($target, $view, $key)
};
}
#[cfg(test)]
mod test {
use super::*;
use crate::burner::{
descriptors::ToleranceDesc,
testing::audit::{
AuditProbeEvent,
AuditProbeEventHeader,
AuditProbeEventStub,
audit_probe::AuditProbeEventParams,
},
};
fn event(data: HashMap<String, Vec<TensorData>>) -> AuditProbeEvent {
AuditProbeEvent {
header: AuditProbeEventHeader::new(None, None, None),
params: AuditProbeEventParams::AssertTensorApproxEx {
tolerance: ToleranceDesc::of::<f32>(Default::default()).unwrap(),
},
data,
}
}
#[test]
fn test_arity_forms() -> BunsenResult<()> {
let a = TensorData::from([1, 2, 3]);
let b = TensorData::from([[2.0, 3.0], [4.0, 5.0]]);
let e = event(HashMap::from([
("solo".to_string(), vec![a.clone()]),
("pair".to_string(), vec![a.clone(), b.clone()]),
("rest".to_string(), vec![b.clone(), a.clone(), b.clone()]),
]));
let [unpacked] = unpack_audit_probe_event_data!([&e], {
solo,
pair: [2],
rest: [..],
})?;
assert_eq!(unpacked.solo, &a);
assert_eq!(unpacked.pair, [&a, &b]);
assert_eq!(unpacked.rest, vec![&b, &a, &b]);
Ok(())
}
#[test]
fn test_multiple_targets() -> BunsenResult<()> {
let a = TensorData::from([1, 2, 3]);
let b = TensorData::from([4, 5, 6]);
let lhs = event(HashMap::from([("data".to_string(), vec![a.clone()])]));
let rhs = event(HashMap::from([("data".to_string(), vec![b.clone()])]));
let [l, r] = unpack_audit_probe_event_data!([&lhs, &rhs], { data })?;
assert_eq!(l.data, &a);
assert_eq!(r.data, &b);
Ok(())
}
#[test]
fn test_heterogeneous_targets() -> BunsenResult<()> {
let a = TensorData::from([1, 2, 3]);
let owned = event(HashMap::from([("data".to_string(), vec![a.clone()])]));
let stub = AuditProbeEventStub {
header: AuditProbeEventHeader::new(None, None, None),
params: AuditProbeEventParams::AssertTensorApproxEx {
tolerance: ToleranceDesc::of::<f32>(Default::default())?,
},
data: HashMap::from([("data".to_string(), vec![&a])]),
};
let [from_owned, from_stub] = unpack_audit_probe_event_data!([&owned, &stub], { data })?;
assert_eq!(from_owned.data, from_stub.data);
Ok(())
}
#[test]
fn test_rejects_undeclared_key() {
let a = TensorData::from([1, 2, 3]);
let e = event(HashMap::from([
("data".to_string(), vec![a.clone()]),
("grad".to_string(), vec![a.clone()]),
]));
let err = unpack_audit_probe_event_data!([&e], { data }).unwrap_err();
let msg = err.to_string();
assert!(msg.contains("in `&e`"), "{msg}");
assert!(
msg.contains("unexpected event data keys [\"grad\"]"),
"{msg}"
);
assert!(msg.contains("pattern declares [\"data\"]"), "{msg}");
}
#[test]
fn test_rejects_missing_key() {
let a = TensorData::from([1, 2, 3]);
let e = event(HashMap::from([("data".to_string(), vec![a.clone()])]));
let err = unpack_audit_probe_event_data!([&e], { data, grad }).unwrap_err();
let msg = err.to_string();
assert!(msg.contains("missing event data key `grad`"), "{msg}");
assert!(msg.contains("present keys [\"data\"]"), "{msg}");
}
#[test]
fn test_rejects_wrong_arity() {
let a = TensorData::from([1, 2, 3]);
let e = event(HashMap::from([(
"data".to_string(),
vec![a.clone(), a.clone()],
)]));
let solo = unpack_audit_probe_event_data!([&e], { data }).unwrap_err();
assert!(
solo.to_string()
.contains("key `data` has 2 values, expected 1"),
"{solo}"
);
let fixed = unpack_audit_probe_event_data!([&e], { data: [3] }).unwrap_err();
assert!(
fixed
.to_string()
.contains("key `data` has 2 values, expected 3"),
"{fixed}"
);
}
#[test]
fn test_names_the_failing_target() {
let a = TensorData::from([1, 2, 3]);
let good = event(HashMap::from([("data".to_string(), vec![a.clone()])]));
let bad = event(HashMap::from([("other".to_string(), vec![a.clone()])]));
let err = unpack_audit_probe_event_data!([&good, &bad], { data }).unwrap_err();
assert!(err.to_string().contains("in `&bad`"), "{err}");
}
}