chalk-remote-call-python 1.6.1__tar.gz → 1.6.3__tar.gz

{chalk_remote_call_python-1.6.1 → chalk_remote_call_python-1.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chalk-remote-call-python
-Version: 1.6.1
+Version: 1.6.3
 Summary: Chalk remote call Python runtime interface client
 Author: Chalk AI, Inc.
 Project-URL: Homepage, https://chalk.ai
@@ -31,6 +31,10 @@ Requires-Dist: grpcio-health-checking>=1.60.0; extra == "dev"
 Requires-Dist: grpcio-reflection>=1.60.0; extra == "dev"
 Requires-Dist: protobuf>=4.25.0; extra == "dev"
 Requires-Dist: grpcio-tools>=1.60.0; extra == "dev"
+Provides-Extra: tracing
+Requires-Dist: opentelemetry-api>=1.20.0; extra == "tracing"
+Requires-Dist: opentelemetry-sdk>=1.20.0; extra == "tracing"
+Requires-Dist: opentelemetry-exporter-otlp-proto-grpc>=1.20.0; extra == "tracing"
 
 # chalk-remote-call-python
 

{chalk_remote_call_python-1.6.1 → chalk_remote_call_python-1.6.3}/chalk-remote-call-rs/chalk-remote-call-server/src/python_bridge.rs

@@ -1,7 +1,10 @@
 use std::collections::HashMap;
 
+use chalk_remote_call_proto::chalk::runtime::v1::CallFunctionResponse;
 use pyo3::prelude::*;
 use pyo3::types::{PyBytes, PyDict, PyList};
+use tokio::sync::mpsc;
+use tonic::Status;
 
 /// Holds references to the Python handler and bridge function.
 pub struct PythonHandler {
@@ -34,29 +37,35 @@ impl PythonHandler {
         }
     }
 
-    /// Non-batched: one caller per invocation. Dispatches to `process_batches`.
-    ///
-    /// Returns a list of IPC-encoded response chunks — multiple when the
-    /// handler is a generator, one otherwise.
-    pub async fn call(
+    /// Non-batched streaming dispatch. Calls `process_batches(..., emit)` so
+    /// generator results are sent to the gRPC stream as each yield is encoded.
+    pub async fn call_streaming(
         &self,
         ipc_bytes: Vec<u8>,
         function_name: String,
         metadata: HashMap<String, String>,
         peer: String,
-    ) -> Result<Vec<Vec<u8>>, PythonError> {
+        response_tx: mpsc::Sender<Result<CallFunctionResponse, Status>>,
+    ) -> Result<(), PythonError> {
         let (handler, process_fn) =
             Python::attach(|py| (self.handler.clone_ref(py), self.process_fn.clone_ref(py)));
         let arg_names = self.arg_names.clone();
 
         tokio::task::spawn_blocking(move || {
-            Python::attach(|py| -> Result<Vec<Vec<u8>>, PythonError> {
+            Python::attach(|py| -> Result<(), PythonError> {
                 let py_bytes = PyBytes::new(py, &ipc_bytes).into_any().unbind();
                 let py_ctx = build_context(py, &function_name, &metadata, &peer)?
                     .into_any()
                     .unbind();
                 let py_arg_names = build_arg_names(py, arg_names.as_deref())?;
-                invoke_process_fn(py, &process_fn, &handler, py_bytes, py_arg_names, py_ctx)
+                let emitter = Py::new(py, ChunkEmitter { response_tx })
+                    .map_err(|e| into_python_error(py, e))?
+                    .into_any();
+
+                process_fn
+                    .call1(py, (py_bytes, handler, py_arg_names, py_ctx, emitter))
+                    .map_err(|e| into_python_error(py, e))?;
+                Ok(())
             })
         })
         .await
@@ -104,6 +113,24 @@ impl PythonHandler {
 
 // ---- Shared helpers -------------------------------------------------------
 
+#[pyclass]
+struct ChunkEmitter {
+    response_tx: mpsc::Sender<Result<CallFunctionResponse, Status>>,
+}
+
+#[pymethods]
+impl ChunkEmitter {
+    fn __call__(&self, chunk: &Bound<'_, PyBytes>) -> PyResult<()> {
+        let msg = CallFunctionResponse {
+            feather_stream: chunk.as_bytes().to_vec().into(),
+        };
+        self.response_tx
+            .blocking_send(Ok(msg))
+            .map_err(|_| pyo3::exceptions::PyRuntimeError::new_err("client disconnected"))?;
+        Ok(())
+    }
+}
+
 /// Build a `{"function_name": str, "peer": str, "metadata": dict}` context dict for one caller.
 fn build_context<'py>(
     py: Python<'py>,

{chalk_remote_call_python-1.6.1 → chalk_remote_call_python-1.6.3}/chalk-remote-call-rs/chalk-remote-call-server/src/service.rs

@@ -91,21 +91,15 @@ impl RemoteCallService for RemoteCallServiceImpl {
         // Single-request path.
         let handler = self.python_handler.clone();
         tokio::spawn(async move {
-            match handler.call(all_bytes, function_name, metadata, peer).await {
-                Ok(response_chunks) => {
-                    for chunk in response_chunks {
-                        let msg = CallFunctionResponse {
-                            feather_stream: chunk.into(),
-                        };
-                        if tx.send(Ok(msg)).await.is_err() {
-                            // Client disconnected
-                            break;
-                        }
-                    }
-                }
+            let error_tx = tx.clone();
+            match handler
+                .call_streaming(all_bytes, function_name, metadata, peer, tx)
+                .await
+            {
+                Ok(()) => {}
                 Err(e) => {
                     error!("Python handler error: {}", e);
-                    let _ = tx
+                    let _ = error_tx
                         .send(Err(Status::unknown(format!(
                             "Exception raised during handler execution: {e}"
                         ))))

chalk_remote_call_python-1.6.3/chalk_remote_call/_version.py

@@ -0,0 +1 @@
+__version__ = "1.6.3"

{chalk_remote_call_python-1.6.1 → chalk_remote_call_python-1.6.3}/chalk_remote_call/servicer.py

@@ -158,11 +158,22 @@ def _collect_async_gen(agen) -> list:
     return _run_async(_collect())
 
 
+def _drain_async_gen(agen, emit: Callable[[bytes], None]) -> None:
+    """Drain an async generator and emit each encoded item immediately."""
+
+    async def _drain():
+        async for item in agen:
+            emit(encode_record_batch(_coerce_to_record_batch(item)))
+
+    _run_async(_drain())
+
+
 def process_batches(
     ipc_bytes: bytes,
     handler: Callable[..., Any],
     arg_names: list[str] | None,
     context_metadata: dict[str, Any],
+    emit: Callable[[bytes], None] | None = None,
 ) -> list[bytes]:
     """Bridge function called from Rust via PyO3.
 
@@ -170,9 +181,18 @@ def process_batches(
     coerces the result, and encodes the response.
 
     Returns a list of IPC-encoded response bytes (one per input batch).
+    When ``emit`` is provided, each encoded response is emitted immediately and
+    the returned list is empty.
     """
     batches = decode_ipc_stream(ipc_bytes)
     results = []
+
+    def append_or_emit(chunk: bytes) -> None:
+        if emit is None:
+            results.append(chunk)
+        else:
+            emit(chunk)
+
     for batch in batches:
         try:
             event = transform(batch, arg_names)
@@ -193,15 +213,19 @@ def process_batches(
                     # Sync generator: encode each yielded value as a separate chunk.
                     for item in result:
                         result_batch = _coerce_to_record_batch(item)
-                        results.append(encode_record_batch(result_batch))
+                        append_or_emit(encode_record_batch(result_batch))
                 elif inspect.isasyncgen(result):
-                    # Async generator: collect items and encode each as a separate chunk.
-                    for item in _collect_async_gen(result):
-                        result_batch = _coerce_to_record_batch(item)
-                        results.append(encode_record_batch(result_batch))
+                    # Async generator: stream when possible, otherwise preserve
+                    # the existing list-returning bridge contract.
+                    if emit is not None:
+                        _drain_async_gen(result, emit)
+                    else:
+                        for item in _collect_async_gen(result):
+                            result_batch = _coerce_to_record_batch(item)
+                            results.append(encode_record_batch(result_batch))
                 else:
                     result_batch = _coerce_to_record_batch(result)
-                    results.append(encode_record_batch(result_batch))
+                    append_or_emit(encode_record_batch(result_batch))
             except Exception as e:
                 raise RuntimeError(f"Failed to encode response: {e}") from e
 

{chalk_remote_call_python-1.6.1 → chalk_remote_call_python-1.6.3}/chalk_remote_call_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chalk-remote-call-python
-Version: 1.6.1
+Version: 1.6.3
 Summary: Chalk remote call Python runtime interface client
 Author: Chalk AI, Inc.
 Project-URL: Homepage, https://chalk.ai
@@ -31,6 +31,10 @@ Requires-Dist: grpcio-health-checking>=1.60.0; extra == "dev"
 Requires-Dist: grpcio-reflection>=1.60.0; extra == "dev"
 Requires-Dist: protobuf>=4.25.0; extra == "dev"
 Requires-Dist: grpcio-tools>=1.60.0; extra == "dev"
+Provides-Extra: tracing
+Requires-Dist: opentelemetry-api>=1.20.0; extra == "tracing"
+Requires-Dist: opentelemetry-sdk>=1.20.0; extra == "tracing"
+Requires-Dist: opentelemetry-exporter-otlp-proto-grpc>=1.20.0; extra == "tracing"
 
 # chalk-remote-call-python
 

{chalk_remote_call_python-1.6.1 → chalk_remote_call_python-1.6.3}/chalk_remote_call_python.egg-info/requires.txt

@@ -9,3 +9,8 @@ grpcio-health-checking>=1.60.0
 grpcio-reflection>=1.60.0
 protobuf>=4.25.0
 grpcio-tools>=1.60.0
+
+[tracing]
+opentelemetry-api>=1.20.0
+opentelemetry-sdk>=1.20.0
+opentelemetry-exporter-otlp-proto-grpc>=1.20.0

{chalk_remote_call_python-1.6.1 → chalk_remote_call_python-1.6.3}/pyproject.toml

@@ -44,6 +44,11 @@ dev = [
     "protobuf>=4.25.0",
     "grpcio-tools>=1.60.0",
 ]
+tracing = [
+    "opentelemetry-api>=1.20.0",
+    "opentelemetry-sdk>=1.20.0",
+    "opentelemetry-exporter-otlp-proto-grpc>=1.20.0",
+]
 
 [project.urls]
 Homepage = "https://chalk.ai"

chalk_remote_call_python-1.6.1/chalk_remote_call/_version.py

@@ -1 +0,0 @@
-__version__ = "1.6.1"