Method embed_batch_parallel

python/src/embeddings/client.rs:110–194

(
        &self,
        py: Python<'_>,
        texts_batch: Vec<Vec<String>>,
        max_concurrency: Option<usize>,
        timeout_ms: Option<u64>,
    )

    /// ```
    #[pyo3(signature = (texts_batch, max_concurrency=None, timeout_ms=None))]
    fn embed_batch_parallel(
        &self,
        py: Python<'_>,
        texts_batch: Vec<Vec<String>>,
        max_concurrency: Option<usize>,
        timeout_ms: Option<u64>,
    ) -> PyResult<Py<PyDict>> {
        // Validate input
        if texts_batch.is_empty() {
            return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
                "Batch cannot be empty",
            ));
        }

        // Build batch request
        let requests: Vec<EmbeddingRequest> = texts_batch
            .into_iter()
            .map(|texts| EmbeddingRequest {
                input: EmbeddingInput::Multiple(texts),
                user: None,
                params: HashMap::new(),
            })
            .collect();

        let batch_request = EmbeddingBatchRequest {
            requests,
            max_concurrency,
            timeout_ms,
        };

        let service = Arc::clone(&self.service);
        let rt = get_runtime();

        // CRITICAL: Release GIL during lock-free parallel execution
        // This enables true parallelism with atomic operations for concurrency control
        let batch_response = py.allow_threads(|| {
            rt.block_on(async move {
                service
                    .process_batch(batch_request)
                    .await
                    .map_err(to_py_runtime_error)
            })
        })?;

        // Convert response to Python dictionary
        let result_dict = PyDict::new(py);

        // Extract embeddings from successful responses
        let mut all_embeddings: Vec<Vec<Vec<f32>>> = Vec::new();
        let mut errors: Vec<String> = Vec::new();

        for (idx, response_result) in batch_response.responses.into_iter().enumerate() {
            match response_result {
                Ok(response) => {
                    all_embeddings.push(response.embeddings);
                }
                Err(e) => {
                    errors.push(format!("Batch {}: {}", idx, e));