chalk-remote-call-python 1.10.9__tar.gz → 1.10.11__tar.gz

{chalk_remote_call_python-1.10.9/chalk_remote_call_python.egg-info → chalk_remote_call_python-1.10.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chalk-remote-call-python
-Version: 1.10.9
+Version: 1.10.11
 Summary: Chalk remote call Python runtime interface client
 Author: Chalk AI, Inc.
 Project-URL: Homepage, https://chalk.ai
@@ -186,6 +186,18 @@ def handler(event, context):
 serve(handler=handler, port=8080)
 ```
 
+### Invocation context
+
+Each Python bridge invocation runs in a fresh `contextvars.Context`. Handler
+changes to context variables stay within that invocation, including across
+awaits and generator iteration, and are discarded on return or error. Incoming
+request metadata still supplies the tracing parent. A coalesced batch has one
+invocation context for the whole batch.
+
+Workers retain their Python thread state for compatibility with native
+extensions. This context boundary does not reset process globals or
+`threading.local()` storage, whose lifetime follows the worker thread.
+
 ## Local Testing
 
 Use `grpcurl` to verify the server is running:

{chalk_remote_call_python-1.10.9 → chalk_remote_call_python-1.10.11}/README.md

@@ -147,6 +147,18 @@ def handler(event, context):
 serve(handler=handler, port=8080)
 ```
 
+### Invocation context
+
+Each Python bridge invocation runs in a fresh `contextvars.Context`. Handler
+changes to context variables stay within that invocation, including across
+awaits and generator iteration, and are discarded on return or error. Incoming
+request metadata still supplies the tracing parent. A coalesced batch has one
+invocation context for the whole batch.
+
+Workers retain their Python thread state for compatibility with native
+extensions. This context boundary does not reset process globals or
+`threading.local()` storage, whose lifetime follows the worker thread.
+
 ## Local Testing
 
 Use `grpcurl` to verify the server is running:

{chalk_remote_call_python-1.10.9 → chalk_remote_call_python-1.10.11}/chalk-remote-call-rs/Cargo.lock

@@ -511,7 +511,7 @@ dependencies = [
 [[package]]
 name = "chalk-queue"
 version = "0.0.0"
-source = "git+https://github.com/chalk-ai/chalk-private.git?rev=1460144ea659debbaee9dccadcd4d7dbf383ccf8#1460144ea659debbaee9dccadcd4d7dbf383ccf8"
+source = "git+https://github.com/chalk-ai/chalk-private.git?rev=6156b025245e28f409bd6c115cfa158ed60203ea#6156b025245e28f409bd6c115cfa158ed60203ea"
 dependencies = [
  "base64 0.22.1",
  "redis",

{chalk_remote_call_python-1.10.9 → chalk_remote_call_python-1.10.11}/chalk-remote-call-rs/chalk-remote-call-server/Cargo.toml

@@ -45,7 +45,7 @@ futures-util = "0.3"
 # `[patch.crates-io]` here it builds against vanilla crates.io redis (it only
 # uses standard APIs). Metrics and StatsD share a revision so their client types agree.
 [target.'cfg(target_os = "linux")'.dependencies]
-chalk-queue = { git = "https://github.com/chalk-ai/chalk-private.git", rev = "1460144ea659debbaee9dccadcd4d7dbf383ccf8" }
+chalk-queue = { git = "https://github.com/chalk-ai/chalk-private.git", rev = "6156b025245e28f409bd6c115cfa158ed60203ea" }
 chalk_metrics = { git = "https://github.com/chalk-ai/chalk-private.git", rev = "a0f8932ec10d3b8340af3e98cf63b800d60b4926" }
 chalk_statsd = { git = "https://github.com/chalk-ai/chalk-private.git", rev = "a0f8932ec10d3b8340af3e98cf63b800d60b4926" }
 

{chalk_remote_call_python-1.10.9 → chalk_remote_call_python-1.10.11}/chalk-remote-call-rs/chalk-remote-call-server/src/self_consumer.rs

@@ -42,7 +42,7 @@ use std::str::FromStr;
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
 
-use chalk_queue::semaphore::renew_many;
+use chalk_queue::semaphore::{release_many, renew_many};
 use chalk_queue::stream_writer;
 use chalk_queue::types::{DeliveryAttempt, QueuedCall};
 use chalk_queue::{
@@ -802,7 +802,7 @@ async fn run_stream_dispatch_loop(
     input_queue: BoundFunctionQueue,
     legacy_queue: Option<BoundFunctionQueue>,
     sem: chalk_queue::DistributedSemaphore,
-    conn: ConnectionManager,
+    mut conn: ConnectionManager,
     consumer_name: String,
     live_calls: LiveCalls,
     handler: Arc<PythonHandler>,
@@ -877,23 +877,23 @@ async fn run_stream_dispatch_loop(
             }
         }
 
+        // Return unused reservations in one round-trip before dispatching work.
+        // Transferring the tokens prevents Drop from also releasing each lease.
+        let used = deliveries.len().min(leases.len());
+        let unused_tokens = leases
+            .split_off(used)
+            .into_iter()
+            .map(SemaphoreLease::into_token)
+            .collect::<Vec<_>>();
+        let _ = release_many(&mut conn, sem.key(), &unused_tokens).await;
+
         if deliveries.is_empty() {
-            for lease in leases {
-                let _ = lease.release().await;
-            }
             tokio::time::sleep(backoff).await;
             backoff = (backoff * 2).min(config.poll_backoff_max);
             continue;
         }
 
         backoff = config.poll_backoff_initial;
-        // `dequeue_many` can return fewer records than requested. Only retain
-        // one lease per record and immediately return the unneeded capacity.
-        let used = deliveries.len().min(leases.len());
-        let unused = leases.split_off(used);
-        for lease in unused {
-            let _ = lease.release().await;
-        }
         for (delivery, lease) in deliveries.into_iter().zip(leases) {
             dispatch_delivery(
                 queue.clone(),

chalk_remote_call_python-1.10.11/chalk_remote_call/_version.py

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

{chalk_remote_call_python-1.10.9 → chalk_remote_call_python-1.10.11}/chalk_remote_call/servicer.py

@@ -4,7 +4,9 @@ import asyncio
 import dataclasses
 import inspect
 from collections.abc import Callable
-from typing import Any
+from contextvars import Context
+from functools import wraps
+from typing import Any, ParamSpec, TypeVar
 
 import pyarrow as pa
 import pyarrow.ipc as ipc
@@ -13,6 +15,18 @@ from chalk_remote_call.arrow_utils import decode_ipc_stream, encode_record_batch
 from chalk_remote_call.input_transform import resolve_column_names, transform
 from chalk_remote_call.tracing import remote_function_invocation_span
 
+_Params = ParamSpec("_Params")
+_Result = TypeVar("_Result")
+
+
+def _isolated_context(function: Callable[_Params, _Result]) -> Callable[_Params, _Result]:
+    @wraps(function)
+    def invoke(*args: _Params.args, **kwargs: _Params.kwargs) -> _Result:
+        # Keep native thread state reusable while request ContextVars start empty.
+        return Context().run(function, *args, **kwargs)
+
+    return invoke
+
 
 def _is_structured(obj: Any) -> bool:
     """Return True if *obj* is a recognised structured-type instance."""
@@ -124,27 +138,19 @@ def _coerce_to_record_batch(result: Any) -> pa.RecordBatch:
         raise TypeError(f"Cannot convert handler result of type {type(result).__name__} to RecordBatch: {e}") from e
 
 
-def _get_or_create_event_loop() -> asyncio.AbstractEventLoop:
-    """Get the running event loop or create a new one."""
+def _run_async(coro):
+    """Run a coroutine synchronously and close its owned event loop."""
     try:
-        return asyncio.get_running_loop()
+        asyncio.get_running_loop()
     except RuntimeError:
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        return loop
-
-
-def _run_async(coro):
-    """Run a coroutine synchronously."""
-    loop = _get_or_create_event_loop()
-    if loop.is_running():
-        # Already inside an async context — can't use run_until_complete.
-        # Create a new loop in a thread.
+        pass
+    else:
+        # A caller's running loop stays on its own thread and remains open.
         import concurrent.futures
 
         with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
             return pool.submit(asyncio.run, coro).result()
-    return loop.run_until_complete(coro)
+    return asyncio.run(coro)
 
 
 def _drain_async_gen(agen, emit: Callable[[bytes], None]) -> None:
@@ -157,6 +163,7 @@ def _drain_async_gen(agen, emit: Callable[[bytes], None]) -> None:
     _run_async(_drain())
 
 
+@_isolated_context
 def process_batches(
     ipc_bytes: bytes,
     handler: Callable[..., Any],
@@ -210,6 +217,7 @@ def _concat_batches(batches: list[pa.RecordBatch]) -> pa.RecordBatch:
     return pa.Table.from_batches(batches).combine_chunks().to_batches()[0]
 
 
+@_isolated_context
 def process_batches_coalesced(
     items_ipc_bytes: list[bytes],
     handler: Callable[..., Any],
@@ -292,6 +300,7 @@ def process_batches_coalesced(
     return output
 
 
+@_isolated_context
 def process_batches_coalesced_combined(
     items_ipc_bytes: list[bytes],
     handler: Callable[..., Any],

{chalk_remote_call_python-1.10.9 → chalk_remote_call_python-1.10.11/chalk_remote_call_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chalk-remote-call-python
-Version: 1.10.9
+Version: 1.10.11
 Summary: Chalk remote call Python runtime interface client
 Author: Chalk AI, Inc.
 Project-URL: Homepage, https://chalk.ai
@@ -186,6 +186,18 @@ def handler(event, context):
 serve(handler=handler, port=8080)
 ```
 
+### Invocation context
+
+Each Python bridge invocation runs in a fresh `contextvars.Context`. Handler
+changes to context variables stay within that invocation, including across
+awaits and generator iteration, and are discarded on return or error. Incoming
+request metadata still supplies the tracing parent. A coalesced batch has one
+invocation context for the whole batch.
+
+Workers retain their Python thread state for compatibility with native
+extensions. This context boundary does not reset process globals or
+`threading.local()` storage, whose lifetime follows the worker thread.
+
 ## Local Testing
 
 Use `grpcurl` to verify the server is running:

chalk_remote_call_python-1.10.9/chalk_remote_call/_version.py

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