use super::machine::Machine;
use super::np_rebuild::as_dtype;
use crate::dtype::DType;
use crate::error::{Error, Result};
use crate::value::{from_bytes, Value};
fn is_wrapper(v: &Value) -> bool {
matches!(v, Value::Object(o)
if o.module.starts_with("joblib") && o.name.ends_with("ArrayWrapper"))
}
impl<'a, 'b> Machine<'a, 'b> {
pub(crate) fn joblib_payload(&mut self, built: Value) -> Result<Value> {
if !is_wrapper(&built) {
return Ok(built);
}
let o = match &built {
Value::Object(o) => o,
_ => unreachable!(),
};
let state = o
.state
.as_deref()
.and_then(|s| s.as_dict())
.ok_or_else(|| Error::pickle("joblib wrapper without a state dict"))?;
let shape: Vec<usize> = match state.get("shape") {
Some(Value::Tuple(t)) | Some(Value::List(t)) => {
t.iter().map(|x| x.as_i64().unwrap_or(0) as usize).collect()
}
_ => return Err(Error::pickle("joblib wrapper without a shape")),
};
let (dt, endian) = as_dtype(
state.get("dtype").ok_or_else(|| Error::pickle("joblib wrapper without a dtype"))?,
)?;
let fortran = state.get("order").and_then(|v| v.as_str()) == Some("F");
if let Some(v) = state.get("numpy_array_alignment_bytes") {
if !matches!(v, Value::None) {
let pad = self.cur.u8()? as usize;
self.cur.skip(pad)?;
}
}
if dt == DType::Object {
let rest = &self.cur.buffer()[self.cur.pos()..];
let mut sub = Machine::new(rest, self.opts);
let v = sub.run()?;
let used = sub.offset();
self.cur.skip(used)?;
return Ok(v);
}
let n: usize = shape.iter().product();
let esz = dt.size().ok_or_else(|| Error::unsupported("variable-size joblib dtype"))?;
if n * esz > self.opts.max_alloc {
return Err(Error::invalid("joblib array exceeds max_alloc"));
}
let raw = self.cur.take(n * esz)?;
let read_shape: Vec<usize> =
if fortran { shape.iter().rev().copied().collect() } else { shape.clone() };
let mut arr = from_bytes(&dt, endian, &read_shape, raw)?;
if fortran && shape.len() > 1 {
let axes: Vec<usize> = (0..shape.len()).rev().collect();
arr = crate::formats::permute(arr, &axes);
}
Ok(Value::Array(crate::formats::apply_cast(arr, self.opts)?))
}
}