chalk-remote-call-python 1.4.0__tar.gz → 1.5.1__tar.gz

{chalk_remote_call_python-1.4.0/chalk_remote_call_python.egg-info → chalk_remote_call_python-1.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chalk-remote-call-python
-Version: 1.4.0
+Version: 1.5.1
 Summary: Chalk remote call Python runtime interface client
 Author: Chalk AI, Inc.
 Project-URL: Homepage, https://chalk.ai
@@ -11,6 +11,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python
 Classifier: Typing :: Typed
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
@@ -18,7 +19,7 @@ Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Topic :: Software Development :: Code Generators
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: <3.14,>=3.10
+Requires-Python: <3.15,>=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: pyarrow>=14.0.0
 Provides-Extra: dev

{chalk_remote_call_python-1.4.0 → chalk_remote_call_python-1.5.1}/chalk-remote-call-rs/Cargo.lock

@@ -1066,11 +1066,10 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.24.2"
+version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5203598f366b11a02b13aa20cab591229ff0a89fd121a308a5df751d5fc9219"
+checksum = "37a6df7eab65fc7bee654a421404947e10a0f7085b6951bf2ea395f4659fb0cf"
 dependencies = [
- "cfg-if",
  "indoc",
  "libc",
  "memoffset",
@@ -1084,19 +1083,18 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.24.2"
+version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99636d423fa2ca130fa5acde3059308006d46f98caac629418e53f7ebb1e9999"
+checksum = "f77d387774f6f6eec64a004eac0ed525aab7fa1966d94b42f743797b3e395afb"
 dependencies = [
- "once_cell",
  "target-lexicon",
 ]
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.24.2"
+version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78f9cf92ba9c409279bc3305b5409d90db2d2c22392d443a87df3a1adad59e33"
+checksum = "2dd13844a4242793e02df3e2ec093f540d948299a6a77ea9ce7afd8623f542be"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -1104,9 +1102,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.24.2"
+version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b999cb1a6ce21f9a6b147dcf1be9ffedf02e0043aec74dc390f3007047cecd9"
+checksum = "eaf8f9f1108270b90d3676b8679586385430e5c0bb78bb5f043f95499c821a71"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -1116,9 +1114,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.24.2"
+version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "822ece1c7e1012745607d5cf0bcb2874769f0f7cb34c4cde03b9358eb9ef911a"
+checksum = "70a3b2274450ba5288bc9b8c1b69ff569d1d61189d4bff38f8d22e03d17f932b"
 dependencies = [
  "heck",
  "proc-macro2",

{chalk_remote_call_python-1.4.0 → chalk_remote_call_python-1.5.1}/chalk-remote-call-rs/chalk-remote-call-server/Cargo.toml

@@ -9,7 +9,7 @@ crate-type = ["cdylib"]
 
 [dependencies]
 chalk-remote-call-proto = { path = "../chalk-remote-call-proto" }
-pyo3 = { version = "0.24", features = ["extension-module"] }
+pyo3 = { version = "0.27", features = ["extension-module"] }
 tonic = "0.12"
 tonic-health = "0.12"
 tonic-reflection = "0.12"

{chalk_remote_call_python-1.4.0 → chalk_remote_call_python-1.5.1}/chalk-remote-call-rs/chalk-remote-call-server/src/lib.rs

@@ -54,7 +54,7 @@ fn start_server(
     };
 
     // Release the GIL while the Rust server runs
-    py.allow_threads(|| {
+    py.detach(|| {
         let rt = tokio::runtime::Builder::new_multi_thread()
             .worker_threads(workers)
             .enable_all()

{chalk_remote_call_python-1.4.0 → chalk_remote_call_python-1.5.1}/chalk-remote-call-rs/chalk-remote-call-server/src/python_bridge.rs

@@ -44,11 +44,11 @@ impl PythonHandler {
         peer: String,
     ) -> Result<Vec<Vec<u8>>, PythonError> {
         let (handler, process_fn) =
-            Python::with_gil(|py| (self.handler.clone_ref(py), self.process_fn.clone_ref(py)));
+            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::with_gil(|py| -> Result<Vec<Vec<u8>>, PythonError> {
+            Python::attach(|py| -> Result<Vec<Vec<u8>>, PythonError> {
                 let py_bytes = PyBytes::new(py, &ipc_bytes).into_any().unbind();
                 let py_ctx = build_context(py, &metadata, &peer)?.into_any().unbind();
                 let py_arg_names = build_arg_names(py, arg_names.as_deref())?;
@@ -67,11 +67,11 @@ impl PythonHandler {
         callers: Vec<CallerInput>,
     ) -> Result<Vec<Vec<u8>>, PythonError> {
         let (handler, process_fn) =
-            Python::with_gil(|py| (self.handler.clone_ref(py), self.process_fn.clone_ref(py)));
+            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::with_gil(|py| -> Result<Vec<Vec<u8>>, PythonError> {
+            Python::attach(|py| -> Result<Vec<Vec<u8>>, PythonError> {
                 let py_inputs = PyList::empty(py);
                 let py_contexts = PyList::empty(py);
                 for c in &callers {
@@ -152,13 +152,14 @@ fn invoke_process_fn(
         .map_err(|e| into_python_error(py, e))?;
 
     let result_list: &Bound<'_, PyList> = result
-        .downcast_bound::<PyList>(py)
+        .bind(py)
+        .cast::<PyList>()
         .map_err(|e| PythonError(format!("bridge must return a list, got: {e}")))?;
 
     let mut out = Vec::with_capacity(result_list.len());
     for item in result_list.iter() {
         let bytes_ref: &Bound<'_, PyBytes> = item
-            .downcast::<PyBytes>()
+            .cast::<PyBytes>()
             .map_err(|e| PythonError(format!("bridge must return list[bytes], got item: {e}")))?;
         out.push(bytes_ref.as_bytes().to_vec());
     }

chalk_remote_call_python-1.5.1/chalk_remote_call/_version.py

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

{chalk_remote_call_python-1.4.0 → chalk_remote_call_python-1.5.1}/chalk_remote_call/cli.py

@@ -80,6 +80,17 @@ def main() -> None:
             "(env: CHALK_REMOTE_CALL_MAX_BUFFER_DURATION_MS)"
         ),
     )
+    parser.add_argument(
+        "--batching-mode",
+        choices=["per_caller", "combined"],
+        default=os.environ.get("CHALK_REMOTE_CALL_BATCHING_MODE") or None,
+        help=(
+            "Coalescing variant when --max-batching-size is set. "
+            "'per_caller' (default) passes events as a list of dicts; "
+            "'combined' passes a single concatenated RecordBatch with "
+            "offsets. (env: CHALK_REMOTE_CALL_BATCHING_MODE)"
+        ),
+    )
     parser.add_argument(
         "--log-level",
         default="INFO",
@@ -135,4 +146,5 @@ def main() -> None:
         arg_names=arg_names,
         max_batching_size=args.max_batching_size,
         max_buffer_duration_ms=args.max_buffer_duration_ms,
+        batching_mode=args.batching_mode,
     )

{chalk_remote_call_python-1.4.0 → chalk_remote_call_python-1.5.1}/chalk_remote_call/server.py

@@ -1,14 +1,38 @@
 from __future__ import annotations
 
 import logging
+import os
 from collections.abc import Callable
-from typing import Any
+from typing import Any, Literal
 
 from chalk_remote_call._native import start_server
-from chalk_remote_call.servicer import process_batches, process_batches_coalesced
+from chalk_remote_call.servicer import (
+    process_batches,
+    process_batches_coalesced,
+    process_batches_coalesced_combined,
+)
 
 logger = logging.getLogger(__name__)
 
+_BATCHING_MODE_ENV = "CHALK_REMOTE_CALL_BATCHING_MODE"
+_VALID_BATCHING_MODES = ("per_caller", "combined")
+
+
+def _resolve_batching_mode(kwarg: str | None) -> str:
+    """Resolve batching mode from kwarg or env var.
+
+    Precedence: explicit kwarg > env var > default "per_caller". The env var
+    is the canonical opt-in for combined mode; the kwarg exists so embedders
+    can override programmatically.
+    """
+    if kwarg is not None:
+        mode = kwarg
+    else:
+        mode = (os.environ.get(_BATCHING_MODE_ENV, "") or "per_caller").strip() or "per_caller"
+    if mode not in _VALID_BATCHING_MODES:
+        raise ValueError(f"batching_mode must be one of {_VALID_BATCHING_MODES}, got {mode!r}")
+    return mode
+
 
 def serve(
     handler: Callable[..., Any],
@@ -20,15 +44,21 @@ def serve(
     arg_names: list[str] | None = None,
     max_batching_size: int | None = None,
     max_buffer_duration_ms: int | None = None,
+    batching_mode: Literal["per_caller", "combined"] | None = None,
 ) -> None:
     """Start the gRPC server implementing RemoteCallService.
 
     Args:
         handler: The user's handler function.
             Single-request mode (default): (event, context) -> result.
-            Coalesced mode (when max_batching_size is set):
+            Coalesced per-caller mode (when max_batching_size is set and
+                batching_mode == "per_caller"):
                 (events: list[dict], contexts: list[dict]) -> list[result],
                 one result per input.
+            Coalesced combined mode (when max_batching_size is set and
+                batching_mode == "combined"):
+                (combined: pa.RecordBatch, offsets: list[int], contexts: list[dict])
+                    -> pa.RecordBatch with combined.num_rows rows.
         host: The host to bind to.
         port: The port to bind to.
         workers: Number of worker threads for the tokio runtime.
@@ -40,21 +70,30 @@ def serve(
         max_buffer_duration_ms: Max time in milliseconds to buffer incoming
             requests before flushing even if max_batching_size hasn't been
             reached. Defaults to 1000ms when batching is enabled.
+        batching_mode: "per_caller" (default) or "combined". Only effective
+            when max_batching_size > 0. Overrides the
+            CHALK_REMOTE_CALL_BATCHING_MODE env var when set; otherwise the
+            env var (or "per_caller") wins.
     """
     if on_startup is not None:
         logger.info("Running startup hook...")
         on_startup()
 
+    mode = _resolve_batching_mode(batching_mode)
+
     if max_batching_size is not None and max_batching_size > 0:
-        process_fn = process_batches_coalesced
+        process_fn = process_batches_coalesced_combined if mode == "combined" else process_batches_coalesced
         batch_size = max_batching_size
         duration_ms = max_buffer_duration_ms if max_buffer_duration_ms is not None else 1000
         logger.info(
-            "Batching enabled: max_batching_size=%d max_buffer_duration_ms=%d",
+            "Batching enabled: mode=%s max_batching_size=%d max_buffer_duration_ms=%d",
+            mode,
             batch_size,
             duration_ms,
         )
     else:
+        if mode == "combined":
+            raise ValueError("batching_mode='combined' requires max_batching_size > 0")
         process_fn = process_batches
         batch_size = 0
         duration_ms = 0

{chalk_remote_call_python-1.4.0 → chalk_remote_call_python-1.5.1}/chalk_remote_call/servicer.py

@@ -10,6 +10,7 @@ import pyarrow as pa
 
 from chalk_remote_call.arrow_utils import decode_ipc_stream, encode_record_batch
 from chalk_remote_call.input_transform import transform
+from chalk_remote_call.tracing import remote_function_invocation_span
 
 
 def _is_structured(obj: Any) -> bool:
@@ -178,30 +179,31 @@ def process_batches(
         except Exception as e:
             raise ValueError(f"Input transformation failed: {e}") from e
 
-        try:
-            result = handler(event, context_metadata)
-            # If the handler is async, await the coroutine.
-            if inspect.iscoroutine(result):
-                result = _run_async(result)
-        except Exception as e:
-            raise RuntimeError(f"Exception raised during handler execution: {e}") from e
-
-        try:
-            if inspect.isgenerator(result):
-                # 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))
-            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)
+        with remote_function_invocation_span(context_metadata):
+            try:
+                result = handler(event, context_metadata)
+                # If the handler is async, await the coroutine.
+                if inspect.iscoroutine(result):
+                    result = _run_async(result)
+            except Exception as e:
+                raise RuntimeError(f"Exception raised during handler execution: {e}") from e
+
+            try:
+                if inspect.isgenerator(result):
+                    # 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))
+                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))
+                else:
+                    result_batch = _coerce_to_record_batch(result)
                     results.append(encode_record_batch(result_batch))
-            else:
-                result_batch = _coerce_to_record_batch(result)
-                results.append(encode_record_batch(result_batch))
-        except Exception as e:
-            raise RuntimeError(f"Failed to encode response: {e}") from e
+            except Exception as e:
+                raise RuntimeError(f"Failed to encode response: {e}") from e
 
     return results
 
@@ -273,25 +275,138 @@ def process_batches_coalesced(
 
     # Dispatch. Contexts are passed as a parallel list — handler can correlate
     # per-caller metadata with each event by index.
-    try:
-        result = handler(events, context_metadatas)
-        if inspect.iscoroutine(result):
-            result = _run_async(result)
-    except Exception as e:
-        raise RuntimeError(f"Exception raised during handler execution: {e}") from e
+    with remote_function_invocation_span(context_metadatas, coalesced_count=len(context_metadatas)):
+        try:
+            result = handler(events, context_metadatas)
+            if inspect.iscoroutine(result):
+                result = _run_async(result)
+        except Exception as e:
+            raise RuntimeError(f"Exception raised during handler execution: {e}") from e
+
+        if not isinstance(result, list):
+            raise TypeError(f"Coalesced handler must return a list, got {type(result).__name__}")
+        if len(result) != len(events):
+            raise ValueError(f"Coalesced handler must return one result per input ({len(events)}); got {len(result)}")
+
+        # Coerce and encode each per-caller result.
+        output: list[bytes] = []
+        for i, item in enumerate(result):
+            try:
+                rb = _coerce_to_record_batch(item)
+                output.append(encode_record_batch(rb))
+            except Exception as e:
+                raise RuntimeError(f"Failed to encode response for caller {i}: {e}") from e
+
+    return output
 
-    if not isinstance(result, list):
-        raise TypeError(f"Coalesced handler must return a list, got {type(result).__name__}")
-    if len(result) != len(events):
-        raise ValueError(f"Coalesced handler must return one result per input ({len(events)}); got {len(result)}")
 
-    # Coerce and encode each per-caller result.
-    output: list[bytes] = []
-    for i, item in enumerate(result):
+def process_batches_coalesced_combined(
+    items_ipc_bytes: list[bytes],
+    handler: Callable[..., Any],
+    arg_names: list[str] | None,
+    context_metadatas: list[dict[str, Any]],
+) -> list[bytes]:
+    """Coalesced bridge, combined-RecordBatch variant.
+
+    Vertically concatenates every caller's batches into one RecordBatch,
+    builds a CSR-style offsets array marking caller boundaries, and invokes
+    the handler once. The handler returns one RecordBatch with row count
+    equal to the combined input; the framework slices it back into per-caller
+    responses (zero-copy on Arrow buffers).
+
+    Handler signature:
+        (combined: pa.RecordBatch, offsets: list[int], contexts: list[dict])
+            -> pa.RecordBatch
+
+    `offsets` has length `len(contexts) + 1`; caller `i` owns rows
+    `[offsets[i] : offsets[i+1])`.
+
+    Raises:
+        ValueError: empty input, length mismatch, schema mismatch across
+            callers, arg_names length mismatch, or handler output row count
+            doesn't match combined input.
+        TypeError: handler is a generator / async generator (not supported
+            in coalesced modes — each caller expects exactly one response
+            chunk).
+    """
+    if not items_ipc_bytes:
+        raise ValueError("process_batches_coalesced_combined called with no items")
+    if len(items_ipc_bytes) != len(context_metadatas):
+        raise ValueError(
+            f"items_ipc_bytes ({len(items_ipc_bytes)}) and context_metadatas "
+            f"({len(context_metadatas)}) lengths must match"
+        )
+    if inspect.isgeneratorfunction(handler) or inspect.isasyncgenfunction(handler):
+        raise TypeError("Generator/async-generator handlers are not supported when batching is enabled")
+
+    per_caller: list[pa.RecordBatch] = []
+    reference_schema: pa.Schema | None = None
+    for i, ipc_bytes in enumerate(items_ipc_bytes):
+        batches = decode_ipc_stream(ipc_bytes)
+        if not batches:
+            raise ValueError(f"Caller {i} produced no batches")
+        rb = _concat_batches(batches)
+        if reference_schema is None:
+            reference_schema = rb.schema
+        elif not rb.schema.equals(reference_schema):
+            raise ValueError(
+                f"Schema mismatch in coalesced batch: caller 0 has {reference_schema}, caller {i} has {rb.schema}"
+            )
+        per_caller.append(rb)
+
+    assert reference_schema is not None  # guaranteed by the empty-input check above
+
+    offsets: list[int] = [0]
+    for rb in per_caller:
+        offsets.append(offsets[-1] + rb.num_rows)
+
+    table = pa.Table.from_batches(per_caller)
+    combined_batches = table.combine_chunks().to_batches()
+    if combined_batches:
+        combined = combined_batches[0]
+    else:
+        combined = pa.RecordBatch.from_pydict(
+            {name: [] for name in reference_schema.names},
+            schema=reference_schema,
+        )
+
+    if arg_names is not None:
+        if len(arg_names) != combined.num_columns:
+            raise ValueError(
+                f"CHALK_INPUT_ARGS specifies {len(arg_names)} names but "
+                f"combined batch has {combined.num_columns} columns"
+            )
+        combined = combined.rename_columns(arg_names)
+
+    with remote_function_invocation_span(context_metadatas, coalesced_count=len(context_metadatas)):
         try:
-            rb = _coerce_to_record_batch(item)
-            output.append(encode_record_batch(rb))
+            result = handler(combined, offsets, context_metadatas)
+            if inspect.iscoroutine(result):
+                result = _run_async(result)
         except Exception as e:
-            raise RuntimeError(f"Failed to encode response for caller {i}: {e}") from e
+            raise RuntimeError(f"Exception raised during handler execution: {e}") from e
+
+        if isinstance(result, pa.RecordBatch):
+            result_rb = result
+        else:
+            try:
+                result_rb = _coerce_to_record_batch(result)
+            except Exception as e:
+                raise RuntimeError(f"Failed to coerce handler output: {e}") from e
+
+        if result_rb.num_rows != combined.num_rows:
+            raise ValueError(
+                f"Combined handler must return a RecordBatch with {combined.num_rows} rows "
+                f"(matching input); got {result_rb.num_rows}"
+            )
 
+        output: list[bytes] = []
+        for i in range(len(per_caller)):
+            start = offsets[i]
+            length = offsets[i + 1] - start
+            sliced = result_rb.slice(start, length)
+            try:
+                output.append(encode_record_batch(sliced))
+            except Exception as e:
+                raise RuntimeError(f"Failed to encode response for caller {i}: {e}") from e
     return output

chalk_remote_call_python-1.5.1/chalk_remote_call/tracing.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+import contextlib
+import importlib
+import os
+from collections.abc import Callable, Iterator, Mapping, Sequence
+from typing import Any, cast
+
+_TRACER_NAME = "chalk_remote_call"
+_TRACE_CONTEXT_METADATA_KEYS = ("traceparent", "tracestate", "baggage")
+_REMOTE_FUNCTION_NAME_METADATA = "x-chalk-function-name"
+_REMOTE_FUNCTION_TRACING_ENV_VAR = "CHALK_ENABLE_REMOTE_FUNCTION_TRACING"
+_missing_sdk_tracer = object()
+_missing_otel_modules = object()
+_sdk_get_tracer: Callable[[], Any] | object | None = None
+_otel_modules: tuple[Any, Any, Any] | object | None = None
+
+
+def _raw_metadata(context_metadata: Any) -> Mapping[str, Any] | None:
+    if not isinstance(context_metadata, Mapping):
+        return None
+
+    raw = context_metadata.get("metadata", context_metadata)
+    if isinstance(raw, Mapping):
+        return raw
+    return None
+
+
+def _first_context_with_traceparent(context_metadata: Any) -> Mapping[str, Any] | None:
+    if isinstance(context_metadata, Sequence) and not isinstance(context_metadata, str | bytes):
+        for item in context_metadata:
+            metadata = _raw_metadata(item)
+            if metadata is not None and metadata.get("traceparent"):
+                return metadata
+        return None
+
+    metadata = _raw_metadata(context_metadata)
+    if metadata is not None and metadata.get("traceparent"):
+        return metadata
+    return None
+
+
+def _trace_carrier(metadata: Mapping[str, Any]) -> dict[str, str]:
+    return {
+        str(key).lower(): str(value)
+        for key, value in metadata.items()
+        if str(key).lower() in _TRACE_CONTEXT_METADATA_KEYS and value
+    }
+
+
+def _function_name(metadata: Mapping[str, Any]) -> str:
+    return str(metadata.get(_REMOTE_FUNCTION_NAME_METADATA) or "") or "unknown"
+
+
+def _get_tracer(trace_api: Any) -> Any:
+    global _sdk_get_tracer
+    if _sdk_get_tracer is None:
+        try:
+            sdk_tracing = importlib.import_module("chalkcompute._tracing")
+        except ImportError:
+            _sdk_get_tracer = _missing_sdk_tracer
+        else:
+            _sdk_get_tracer = sdk_tracing.get_tracer
+
+    sdk_get_tracer = _sdk_get_tracer
+    if callable(sdk_get_tracer):
+        try:
+            return sdk_get_tracer()
+        except ImportError:
+            return trace_api.get_tracer(_TRACER_NAME)
+    return trace_api.get_tracer(_TRACER_NAME)
+
+
+def _get_otel_modules() -> tuple[Any, Any, Any] | None:
+    global _otel_modules
+    if _otel_modules is None:
+        try:
+            _otel_modules = (
+                importlib.import_module("opentelemetry.context"),
+                importlib.import_module("opentelemetry.propagate"),
+                importlib.import_module("opentelemetry.trace"),
+            )
+        except ImportError:
+            _otel_modules = _missing_otel_modules
+
+    if _otel_modules is _missing_otel_modules:
+        return None
+    return cast(tuple[Any, Any, Any], _otel_modules)
+
+
+@contextlib.contextmanager
+def remote_function_invocation_span(
+    context_metadata: Any,
+    coalesced_count: int | None = None,
+) -> Iterator[None]:
+    if os.environ.get(_REMOTE_FUNCTION_TRACING_ENV_VAR, "") != "1":
+        yield
+        return
+
+    metadata = _first_context_with_traceparent(context_metadata)
+    if metadata is None:
+        yield
+        return
+
+    carrier = _trace_carrier(metadata)
+    if not carrier:
+        yield
+        return
+
+    otel_modules = _get_otel_modules()
+    if otel_modules is None:
+        yield
+        return
+    otel_context, propagate, trace = otel_modules
+
+    parent_context = propagate.extract(carrier)
+    parent_span_context = trace.get_current_span(parent_context).get_span_context()
+    if not parent_span_context.is_valid:
+        yield
+        return
+
+    SpanKind = trace.SpanKind
+    Status = trace.Status
+    StatusCode = trace.StatusCode
+    function_name = _function_name(metadata)
+    tracer = _get_tracer(trace)
+    with tracer.start_as_current_span(
+        "chalkcompute.remote_function.invoke",
+        context=parent_context,
+        kind=SpanKind.SERVER,
+    ) as span:
+        span.set_attribute("chalk.remote_function.name", function_name)
+        if coalesced_count is not None:
+            span.set_attribute(
+                "chalk.remote_function.coalesced_count",
+                coalesced_count,
+            )
+        if not span.get_span_context().is_valid:
+            token = otel_context.attach(parent_context)
+            try:
+                yield
+            finally:
+                otel_context.detach(token)
+            return
+        try:
+            yield
+        except Exception as exc:
+            span.record_exception(exc)
+            span.set_status(Status(StatusCode.ERROR, str(exc)))
+            raise

{chalk_remote_call_python-1.4.0 → chalk_remote_call_python-1.5.1/chalk_remote_call_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chalk-remote-call-python
-Version: 1.4.0
+Version: 1.5.1
 Summary: Chalk remote call Python runtime interface client
 Author: Chalk AI, Inc.
 Project-URL: Homepage, https://chalk.ai
@@ -11,6 +11,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python
 Classifier: Typing :: Typed
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
@@ -18,7 +19,7 @@ Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Topic :: Software Development :: Code Generators
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: <3.14,>=3.10
+Requires-Python: <3.15,>=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: pyarrow>=14.0.0
 Provides-Extra: dev

{chalk_remote_call_python-1.4.0 → chalk_remote_call_python-1.5.1}/chalk_remote_call_python.egg-info/SOURCES.txt

@@ -29,6 +29,7 @@ chalk_remote_call/handler_loader.py
 chalk_remote_call/input_transform.py
 chalk_remote_call/server.py
 chalk_remote_call/servicer.py
+chalk_remote_call/tracing.py
 chalk_remote_call/_gen/__init__.py
 chalk_remote_call/_gen/chalk/__init__.py
 chalk_remote_call/_gen/chalk/auth/__init__.py

{chalk_remote_call_python-1.4.0 → chalk_remote_call_python-1.5.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "chalk-remote-call-python"
-requires-python = ">=3.10,<3.14"
+requires-python = ">=3.10,<3.15"
 authors = [
     { name = "Chalk AI, Inc." }
 ]
@@ -18,6 +18,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Programming Language :: Python",
     "Typing :: Typed",
     "Topic :: Scientific/Engineering :: Artificial Intelligence",

chalk_remote_call_python-1.4.0/chalk_remote_call/_version.py

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