use std::collections::{BTreeMap, HashSet};
use std::mem::size_of;
use littlegraph_core::{Params, Value};
use pyo3::prelude::*;
use pyo3::types::{PyAny, PyBool, PyFloat, PyInt, PyList, PyString, PyTuple};
use crate::error::BindingError;
use crate::options::Limits;
struct Conversion<'a> {
limits: &'a Limits,
containers: HashSet<usize>,
items: usize,
string_bytes: usize,
retained_bytes: usize,
}
pub(crate) fn parameters_from_python(
py: Python<'_>,
parameters: Option<&Bound<'_, PyAny>>,
limits: &Limits,
) -> Result<Params, BindingError> {
let Some(parameters) = parameters else {
return Ok(Params::new());
};
if parameters.is_none() {
return Ok(Params::new());
}
let mapping = py
.import("collections.abc")
.and_then(|module| module.getattr("Mapping"))
.map_err(|_| BindingError::parameter_type("cannot inspect parameters mapping type"))?;
if !parameters.is_instance(&mapping).unwrap_or(false) {
return Err(BindingError::parameter_type(
"parameters must be a mapping with string keys",
));
}
let mut conversion = Conversion {
limits,
containers: HashSet::new(),
items: 0,
string_bytes: 0,
retained_bytes: 0,
};
conversion.mapping(parameters, "parameters", 0)
}
impl Conversion<'_> {
fn value(
&mut self,
py: Python<'_>,
value: &Bound<'_, PyAny>,
path: &str,
depth: usize,
) -> Result<Value, BindingError> {
self.check_depth(depth, path)?;
self.charge_bytes(size_of::<Value>(), path)?;
if value.is_none() {
return Ok(Value::Null);
}
if value.is_instance_of::<PyBool>() {
return value
.extract::<bool>()
.map(Value::Boolean)
.map_err(|_| BindingError::parameter_type(format!("{path} must be a bool")));
}
if value.is_instance_of::<PyInt>() {
return value.extract::<i64>().map(Value::Integer).map_err(|_| {
BindingError::parameter_value(format!(
"{path} is outside the signed 64-bit integer range"
))
});
}
if value.is_instance_of::<PyFloat>() {
return value
.extract::<f64>()
.map(Value::Float)
.map_err(|_| BindingError::parameter_type(format!("{path} must be a float")));
}
if value.is_instance_of::<PyString>() {
let string = value.extract::<String>().map_err(|_| {
BindingError::parameter_value(format!("{path} is not a valid Python string"))
})?;
self.charge_string(&string, path)?;
return Ok(Value::String(string));
}
if value.is_instance_of::<PyList>() || value.is_instance_of::<PyTuple>() {
return self.sequence(py, value, path, depth);
}
let mapping = py
.import("collections.abc")
.and_then(|module| module.getattr("Mapping"))
.map_err(|_| BindingError::parameter_type("cannot inspect parameter mapping type"))?;
if value.is_instance(&mapping).unwrap_or(false) {
return self.mapping(value, path, depth).map(Value::Map);
}
Err(BindingError::parameter_type(format!(
"{path} has an unsupported parameter type"
)))
}
fn sequence(
&mut self,
py: Python<'_>,
value: &Bound<'_, PyAny>,
path: &str,
depth: usize,
) -> Result<Value, BindingError> {
self.with_container(value, path, |conversion| {
let iterator = value.try_iter().map_err(|_| {
BindingError::parameter_type(format!("{path} must be a list or tuple"))
})?;
let mut values = Vec::new();
for (index, item) in iterator.enumerate() {
conversion.charge_item(path)?;
let item = item.map_err(|_| {
BindingError::parameter_value(format!("failed to read {path}[{index}]"))
})?;
values.push(conversion.value(py, &item, &format!("{path}[{index}]"), depth + 1)?);
}
conversion.charge_bytes(values.capacity() * size_of::<Value>(), path)?;
Ok(Value::List(values))
})
}
fn mapping(
&mut self,
value: &Bound<'_, PyAny>,
path: &str,
depth: usize,
) -> Result<BTreeMap<String, Value>, BindingError> {
self.check_depth(depth, path)?;
self.with_container(value, path, |conversion| {
let items = value
.call_method0("items")
.map_err(|_| BindingError::parameter_type(format!("{path} must be a mapping")))?;
let iterator = items.try_iter().map_err(|_| {
BindingError::parameter_type(format!("{path}.items() must be iterable"))
})?;
let mut result = BTreeMap::new();
for item in iterator {
conversion.charge_item(path)?;
let item = item.map_err(|_| {
BindingError::parameter_value(format!("failed to read an item from {path}"))
})?;
let pair = item.downcast::<PyTuple>().map_err(|_| {
BindingError::parameter_type(format!("{path}.items() returned an invalid item"))
})?;
if pair.len() != 2 {
return Err(BindingError::parameter_type(format!(
"{path}.items() returned an invalid item"
)));
}
let key = pair.get_item(0).map_err(|_| {
BindingError::parameter_type(format!("{path} contains an unreadable key"))
})?;
if !key.is_instance_of::<PyString>() {
return Err(BindingError::parameter_type(format!(
"{path} contains a non-string key"
)));
}
let key = key.extract::<String>().map_err(|_| {
BindingError::parameter_value(format!("{path} contains an invalid string key"))
})?;
conversion.charge_string(&key, path)?;
let item_path = format!("{path}.{key}");
let item_value = pair.get_item(1).map_err(|_| {
BindingError::parameter_type(format!("{item_path} is unreadable"))
})?;
let converted = conversion.value(value.py(), &item_value, &item_path, depth + 1)?;
result.insert(key, converted);
}
conversion.charge_bytes(result.len() * size_of::<(String, Value)>(), path)?;
Ok(result)
})
}
fn with_container<T>(
&mut self,
value: &Bound<'_, PyAny>,
path: &str,
operation: impl FnOnce(&mut Self) -> Result<T, BindingError>,
) -> Result<T, BindingError> {
let identity = value.as_ptr() as usize;
if !self.containers.insert(identity) {
return Err(BindingError::parameter_value(format!(
"{path} contains a reference cycle"
)));
}
let result = operation(self);
self.containers.remove(&identity);
result
}
fn check_depth(&self, depth: usize, path: &str) -> Result<(), BindingError> {
if depth > self.limits.max_parameter_depth {
Err(BindingError::parameter_value(format!(
"{path} exceeds the parameter nesting limit"
)))
} else {
Ok(())
}
}
fn charge_item(&mut self, path: &str) -> Result<(), BindingError> {
self.items = self.items.checked_add(1).ok_or_else(|| {
BindingError::parameter_value(format!("{path} exceeds the parameter item limit"))
})?;
if self.items > self.limits.max_parameter_items {
return Err(BindingError::parameter_value(format!(
"{path} exceeds the parameter item limit"
)));
}
Ok(())
}
fn charge_string(&mut self, value: &str, path: &str) -> Result<(), BindingError> {
self.string_bytes = self.string_bytes.checked_add(value.len()).ok_or_else(|| {
BindingError::parameter_value(format!("{path} exceeds the parameter string limit"))
})?;
if self.string_bytes > self.limits.max_parameter_string_bytes {
return Err(BindingError::parameter_value(format!(
"{path} exceeds the parameter string limit"
)));
}
self.charge_bytes(value.len(), path)
}
fn charge_bytes(&mut self, bytes: usize, path: &str) -> Result<(), BindingError> {
self.retained_bytes = self.retained_bytes.checked_add(bytes).ok_or_else(|| {
BindingError::parameter_value(format!("{path} exceeds the retained parameter limit"))
})?;
if self.retained_bytes > self.limits.max_parameter_bytes {
return Err(BindingError::parameter_value(format!(
"{path} exceeds the retained parameter limit"
)));
}
Ok(())
}
}