Method parse_python_response

core/src/embeddings/python_bridge.rs:44–115

Parse Python response to EmbeddingResponse

(
        &self,
        py: Python<'_>,
        result: PyObject,
    )

    /// Parse Python response to EmbeddingResponse
    fn parse_python_response(
        &self,
        py: Python<'_>,
        result: PyObject,
    ) -> GraphBitResult<EmbeddingResponse> {
        // The Python embedding method should return a list of floats (single embedding)
        // or a list of lists of floats (multiple embeddings)

        let result_bound = result.bind(py);
        let embeddings: Vec<Vec<f32>> = if let Ok(list) = result_bound.downcast::<PyList>() {
            if list.is_empty() {
                return Err(GraphBitError::llm("Empty embedding response from Python"));
            }

            // Check if it's a single embedding (list of floats) or multiple (list of lists)
            let first_item = list.get_item(0).map_err(|e| {
                GraphBitError::llm(format!(
                    "Failed to get first item from Python response: {e}"
                ))
            })?;

            if first_item.downcast::<PyList>().is_ok() {
                // Multiple embeddings (list of lists)
                list.iter()
                    .map(|item| {
                        item.downcast::<PyList>()
                            .map_err(|e| {
                                GraphBitError::llm(format!("Invalid embedding format: {e}"))
                            })?
                            .iter()
                            .map(|v| {
                                v.extract::<f32>().map_err(|e| {
                                    GraphBitError::llm(format!("Failed to extract float: {e}"))
                                })
                            })
                            .collect::<Result<Vec<f32>, _>>()
                    })
                    .collect::<Result<Vec<Vec<f32>>, _>>()?
            } else {
                // Single embedding (list of floats)
                let embedding: Vec<f32> = list
                    .iter()
                    .map(|v| {
                        v.extract::<f32>().map_err(|e| {
                            GraphBitError::llm(format!("Failed to extract float: {e}"))
                        })
                    })
                    .collect::<Result<Vec<f32>, _>>()?;
                vec![embedding]
            }
        } else {
            return Err(GraphBitError::llm(
                "Python embedding response must be a list",
            ));
        };

        // Estimate token usage (Python providers typically don't provide this)
        let total_chars: usize = embeddings.iter().map(|e| e.len()).sum();