littlegraph-python 0.2.1

Python extension module for the littlegraph embedded graph database
Documentation
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(())
    }
}