use std::collections::HashMap;
use burn::prelude::TensorData;
use crate::errors::{
BunsenError,
BunsenResult,
ValueMismatch,
};
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(mismatch(
target,
format!("unexpected event data keys {unexpected:?}; pattern declares {keys:?}"),
))
}
#[track_caller]
fn mismatch(
target: &str,
summary: String,
) -> BunsenError {
BunsenError::from(ValueMismatch::Other {
summary,
details: None,
})
.context(format!("unpacking `{target}`"))
}
#[track_caller]
fn arity_error(
target: &str,
key: &str,
expected: &str,
actual: usize,
) -> BunsenError {
mismatch(
target,
format!("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(mismatch(
target,
format!("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::audit::AuditProbeEventView,
{
let view = $crate::audit::AuditProbeEventView::data_map_view(event);
$crate::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::audit::take_one($target, $view, $key)
};
(@take $target:expr, $view:expr, $key:expr, [..]) => {
$crate::audit::take_any($target, $view, $key)
};
(@take $target:expr, $view:expr, $key:expr, [$n:literal]) => {
$crate::audit::take_fixed::<$n>($target, $view, $key)
};
}
#[cfg(test)]
mod test {
use super::*;
use crate::{
audit::{
AuditProbeEvent,
AuditProbeEventHeader,
AuditProbeEventStub,
audit_probe::AuditProbeEventParams,
},
burner::descriptors::ToleranceDesc,
errors::{
BunsenErrorKind,
testing::{
ErrorMatcher,
text,
},
},
};
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()]),
]));
ErrorMatcher::kind(BunsenErrorKind::Policy)
.frame(text::eq("unpacking `&e`"))
.message_contains("unexpected event data keys [\"grad\"]")
.message_contains("pattern declares [\"data\"]")
.has_cause::<ValueMismatch>()
.assert_err(&unpack_audit_probe_event_data!([&e], { data }));
}
#[test]
fn test_rejects_missing_key() {
let a = TensorData::from([1, 2, 3]);
let e = event(HashMap::from([("data".to_string(), vec![a.clone()])]));
ErrorMatcher::kind(BunsenErrorKind::Policy)
.frame(text::eq("unpacking `&e`"))
.message_contains("missing event data key `grad`")
.message_contains("present keys [\"data\"]")
.assert_err(&unpack_audit_probe_event_data!([&e], { data, grad }));
}
#[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()],
)]));
ErrorMatcher::kind(BunsenErrorKind::Policy)
.message_contains("key `data` has 2 values, expected 1")
.assert_err(&unpack_audit_probe_event_data!([&e], { data }));
ErrorMatcher::kind(BunsenErrorKind::Policy)
.message_contains("key `data` has 2 values, expected 3")
.assert_err(&unpack_audit_probe_event_data!([&e], { data: [3] }));
}
#[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()])]));
ErrorMatcher::kind(BunsenErrorKind::Policy)
.frame(text::eq("unpacking `&bad`"))
.display_contains("unpacking `&bad`: ")
.assert_err(&unpack_audit_probe_event_data!([&good, &bad], { data }));
}
}