chalk-remote-call-python 1.10.5__cp315-cp315-win_amd64.whl

chalk_remote_call_python-1.10.5.dist-info/METADATA

@@ -0,0 +1,288 @@
+Metadata-Version: 2.4
+Name: chalk-remote-call-python
+Version: 1.10.5
+Summary: Chalk remote call Python runtime interface client
+Author: Chalk AI, Inc.
+Project-URL: Homepage, https://chalk.ai
+Project-URL: Documentation, https://docs.chalk.ai
+Project-URL: Changelog, https://docs.chalk.ai/docs/changelog
+Classifier: Programming Language :: Python :: 3
+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 :: 3.15
+Classifier: Programming Language :: Python
+Classifier: Typing :: Typed
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+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.16,>=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pyarrow>=14.0.0
+Provides-Extra: dev
+Requires-Dist: setuptools-rust>=1.7; extra == "dev"
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: grpcio>=1.60.0; extra == "dev"
+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
+
+A Python runtime interface for Chalk's RemoteCallService. This package provides a gRPC server backed by a Rust implementation (tonic + PyO3) that lets you define a `handler(event, context)` function to process incoming Arrow-serialized requests.
+
+The server receives Arrow IPC record batches over a bidirectional gRPC stream, transforms them into a Python dict, invokes your handler, and streams the results back as Arrow IPC.
+
+## Requirements
+
+- Python >= 3.10
+- Rust 1.99.0 (for building the native extension)
+- `pyarrow >= 14.0.0`
+
+## Usage
+
+### 1. Write a handler
+
+Create a Python module with a `handler` function:
+
+```python
+# my_handler.py
+import pyarrow as pa
+import pyarrow.compute as pc
+
+
+def on_startup():
+    """Optional -- runs once before the server starts accepting requests."""
+    print("Loading model weights...")
+
+
+def handler(event: dict[str, pa.Array], context: dict) -> pa.Array:
+    """Called for each incoming request.
+
+    Args:
+        event: dict mapping column names to pyarrow.Array values.
+        context: dict with request metadata
+
+    Returns:
+        A pyarrow.Array, pyarrow.RecordBatch, pyarrow.Table, list, dict, or scalar.
+        The framework auto-converts the result to Arrow IPC for the response.
+    """
+    return pc.multiply(event["x"], event["y"])
+
+
+def on_shutdown():
+    """Optional -- runs once after the server stops accepting requests."""
+    print("Releasing resources...")
+```
+
+### 2. Start the server
+
+```bash
+chalk-remote-call --handler my_handler.handler
+```
+
+Or via `python -m`:
+
+```bash
+python -m chalk_remote_call --handler my_handler.handler
+```
+
+### CLI options
+
+| Flag | Env var | Default | Description |
+|------|---------|---------|-------------|
+| `--handler` | | *(required)* | Dotted path to handler function |
+| `--port` | `CHALK_REMOTE_CALL_PORT` | `6666` | Port to listen on |
+| `--host` | `CHALK_REMOTE_CALL_HOST` | `[::]` | Host to bind to |
+| `--workers` | `CHALK_REMOTE_CALL_WORKERS` | `10` | Tokio runtime worker threads |
+| `--on-startup` | | | Dotted path to a startup function |
+| `--on-shutdown` | | | Dotted path to a shutdown function |
+| `--log-level` | | `INFO` | `DEBUG`, `INFO`, `WARNING`, or `ERROR` |
+
+The CLI writes Python logs to stderr as one JSON object per line, with separate
+`timestamp`, `severity`, `logger`, and `message` fields. Exceptions include an
+`exception.stacktrace` field, which the log collector uses for the traceback.
+CLI logging is configured before importing runtime dependencies. Import failures,
+invalid environment configuration, and exceptions escaping startup or the server
+emit a single ERROR record with the full traceback and exit with status 1.
+Calls to `serve()` from Python retain the embedding application's logging configuration.
+
+On Linux, server shutdown drains buffered function-call metrics before the runtime exits,
+including when the server returns an error. Draining waits up to 10 seconds; a timeout or
+publisher failure is logged as a warning.
+Routine drain messages are logged at DEBUG; set `RUST_LOG=info,_native::metrics=debug`
+to include them.
+
+Missing optional StatsD endpoints or a metrics-bus topic do not emit warnings.
+Failures initializing configured metrics sinks still warn. Routine customer
+StatsD configuration messages are emitted at DEBUG by the shared metrics library;
+set `RUST_LOG=info,chalk_metrics::metrics::config=debug` to include them.
+
+### Environment variables
+
+| Variable | Description |
+|----------|-------------|
+| `CHALK_INPUT_ARGS` | Comma-separated list of column names (e.g. `x,y,z`). Renames incoming RecordBatch columns by index. If unset, the original column names are used. Reserved columns (below) are held out of this mapping and keep their own name. |
+| `CHALK_FNQ_CONSUMER_ENDPOINT` | Opt into DP API `FnqConsumerService` consumption (HTTP or HTTPS gRPC endpoint). Unset preserves direct Redis consumption. API errors never fall back to Redis. |
+| `CHALK_FUNCTION_QUEUE_TOKEN_FILE` | Controller-mounted working JWT, reopened per RPC to observe rotation. Defaults to `/var/run/secrets/chalk-function-queue/identity-token`. The shim does not exchange credentials. |
+| `CHALK_FNQ_QUEUE_PROTOCOL` | Self-consumer work transport: `list_v1` (default/backward compatible) or `stream_v1`. Deployment tooling sets this from immutable scaling-group revision metadata. |
+
+#### Reserved columns
+
+A caller may attach framework side-channel data to a request as an extra column. Reserved
+columns are matched by name, are optional on any given request, and are excluded from the
+positional `CHALK_INPUT_ARGS` mapping — so `CHALK_INPUT_ARGS` always lists exactly the
+handler's declared arguments, whether or not the caller sent one.
+
+| Column | Meaning |
+|--------|---------|
+| `__chalk_row_metadata__` | Per-row binary blob supplied by the caller (Chalk's engine sets it from `catalog_call(..., row_metadata => ...)`). Handlers read it via `chalkcompute.get_row_metadata()`. |
+
+### 3. Docker image
+
+```dockerfile
+FROM python:3.11-slim
+
+WORKDIR /app
+
+RUN pip install chalk-remote-call-python
+
+# Copy your handler code
+COPY my_handler.py /app
+
+EXPOSE 6666
+
+ENTRYPOINT ["chalk-remote-call"]
+CMD ["--handler", "handler.handler"]
+```
+
+Build and run:
+
+```bash
+docker build -t my-chalk-handler .
+docker run -p 6666:6666 -e CHALK_INPUT_ARGS="x,y" my-chalk-handler
+```
+
+### Programmatic usage
+
+You can also start the server from Python:
+
+```python
+from chalk_remote_call import serve
+
+def handler(event, context):
+    return list(event.values())[0]
+
+serve(handler=handler, port=8080)
+```
+
+## Local Testing
+
+Use `grpcurl` to verify the server is running:
+
+```bash
+# Check health
+grpcurl -plaintext localhost:6666 grpc.health.v1.Health/Check
+
+# List services via reflection
+grpcurl -plaintext localhost:6666 list
+```
+
+## Architecture
+
+The server uses a Rust backend via PyO3:
+
+- **tonic** — gRPC server with health checking and reflection
+- **prost** — protobuf message handling
+- **arrow-rs** — Arrow IPC validation
+- **PyO3** — FFI bridge to call Python handler functions
+
+The Rust server runs on a tokio async runtime. When a request arrives, Arrow IPC bytes are passed to Python via PyO3 (`spawn_blocking` + GIL acquisition), where the handler is invoked. Results are passed back as IPC bytes.
+
+## Development
+
+### Setup
+
+```bash
+cd chalk-remote-call-python
+uv venv --python 3.11
+uv pip install -e ".[dev]"
+```
+
+### Running tests
+
+```bash
+pytest tests/ -v
+```
+
+The Linux metrics shutdown regression tests use an in-memory bus publisher:
+
+```bash
+PYO3_PYTHON=python3 cargo test --manifest-path chalk-remote-call-rs/chalk-remote-call-server/Cargo.toml --no-default-features --lib metrics::tests
+```
+
+`--no-default-features` links Python into the test executable; wheel builds retain
+the default `extension-module` feature.
+
+### Rust code
+
+Rust source lives in `chalk-remote-call-rs/`:
+
+To check the Rust code independently:
+
+```bash
+PYO3_PYTHON=python3 cargo check --manifest-path chalk-remote-call-rs/chalk-remote-call-server/Cargo.toml
+```
+
+## Remote exception transport
+
+Handler failures retain their original exception type, message, traceback,
+exception chains, and exception groups. Runtime dispatch frames are excluded
+from the user traceback, along with callers above the handler dispatch boundary.
+Handler frames and their downstream calls remain visible (except for Chalk SDK
+and marked generated dispatch frames); full diagnostics are retained in server
+logs and `internal_stacktrace`.
+
+All call modes carry a JSON payload with `chalk_remote_error: 1` and an
+`exception` object containing the `ChalkException` fields `kind`, `message`,
+`stacktrace`, and `internal_stacktrace`. Direct calls carry the payload as the
+unescaped gRPC status message; queued calls carry it in the error message. The
+local async service additionally populates `ChalkError.exception`. This permits
+existing queue transports to forward structured errors without a protobuf
+migration. Clients must decode the versioned payload, not parse gRPC debug text
+or classify user errors by their message. Unknown versions remain opaque.
+
+Payloads are bounded for gRPC header limits. Truncation is marked explicitly,
+with complete tracebacks kept in server logs. Exception objects and locals are
+never pickled or sent. Chalk SDK-generated handlers identify their dispatch
+frames, and notebook source maps identify the deployed snapshot's lines.
+
+### Fnq integration test
+
+On Linux, build the native extension and the paired `chalk-private` test harness:
+
+```bash
+# chalk-private, inside the Nix dev shell
+bazel build //rust-crates/chalk/dataplane-api-server:fnq_test_server
+
+# chalk-remote-call-python
+uv pip install -e ".[dev]" redis PyJWT cryptography
+FNQ_TEST_SERVER=/path/to/chalk-private/bazel-bin/rust-crates/chalk/dataplane-api-server/fnq_test_server \
+REDIS_URL=redis://127.0.0.1:6379 .venv/bin/pytest tests/test_fnq_api_e2e.py -v
+```
+
+Use an isolated Redis instance. The tests create temporary signing keys and start
+the production JWT layer and Fnq service, then exercise real native-shim execution,
+lease renewal, result writes, token rotation, and environment isolation. These tests
+skip unless `FNQ_TEST_SERVER` and `REDIS_URL` are set. Deploy the service before
+setting `CHALK_FNQ_CONSUMER_ENDPOINT` on a workload.

chalk_remote_call_python-1.10.5.dist-info/RECORD

@@ -0,0 +1,45 @@
+chalk_remote_call/__init__.py,sha256=RV-Gy1rR3Wpg7J5szNEITfX9UUFbDjrDcgBoORr6HK0,134
+chalk_remote_call/__main__.py,sha256=Gw47QG564BmA-sV7Yo8J0_jHwJjHt1YJu9kRXsbajc8,50
+chalk_remote_call/_native.cp315-win_amd64.pyd,sha256=wZxxu-lyii9dihW3MczLuUjj0g_O73jEsmzUtZ2wjHo,6797312
+chalk_remote_call/_native.pyi,sha256=kTF8wh0P8_mWemwRWZ63Aa3l29o1HOKq7JP_fx5Dzyw,341
+chalk_remote_call/_version.py,sha256=CKHegvkApa5CWTJbNvYefNnR9_yZW6PAmMc97wTOQxo,23
+chalk_remote_call/arrow_utils.py,sha256=l4Mlq7Z3VYEAkuFYTU3eBXKIQs0RdIaf-QwIP3A8aak,684
+chalk_remote_call/cli.py,sha256=xyJ-1Qfd-JfefrqhQ1LHk8vWABD4B9qEq29WUPRooKU,5442
+chalk_remote_call/errors.py,sha256=W3iaCSZCDgn6CvRgdcDByQs4MQMUcKhCfqu3ZsL13MA,5078
+chalk_remote_call/handler_loader.py,sha256=jiUIz8_iBoipTFm98KZgloQT9ykBbZP-0pdDquYP-MA,2186
+chalk_remote_call/input_transform.py,sha256=VD8wi0hs2vw_OvrAPB7-_ycnZJkIrYz4WkCjZbNSrfI,2233
+chalk_remote_call/logging.py,sha256=TTXx2m0BtRdLmdNh57bl1c3KBGfAru-gYmSs_vIZSac,1237
+chalk_remote_call/server.py,sha256=pQo_7NIcPY6bfzYHtfUZezQACYTAQu97OPw4GOq7740,4784
+chalk_remote_call/servicer.py,sha256=8xdqMPmnRdReDwWMwt5t5KHcdud4JRWBf6UnntKY64I,17062
+chalk_remote_call/tracing.py,sha256=euHBFC60lE9ta_2NF0mKKotXBtowv7M2Kk9KgWvWbGE,16636
+chalk_remote_call/_gen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chalk_remote_call/_gen/chalk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chalk_remote_call/_gen/chalk/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chalk_remote_call/_gen/chalk/auth/v1/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chalk_remote_call/_gen/chalk/auth/v1/permissions_pb2.py,sha256=OJplIAXNqUVieqTO4yNyRv1J7JqnRTqUPXviceyWf_g,22010
+chalk_remote_call/_gen/chalk/auth/v1/permissions_pb2_grpc.py,sha256=_bXoS025FcWrXR1E_3Mh4GHB1RMvgz8lIpit-Awnf-s,163
+chalk_remote_call/_gen/chalk/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chalk_remote_call/_gen/chalk/common/v1/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chalk_remote_call/_gen/chalk/common/v1/chalk_error_pb2.py,sha256=Eok4HEEnHEUMlu_y-lnIRFPs7zre8p22Gv86uB13YZY,3747
+chalk_remote_call/_gen/chalk/common/v1/chalk_error_pb2_grpc.py,sha256=_bXoS025FcWrXR1E_3Mh4GHB1RMvgz8lIpit-Awnf-s,163
+chalk_remote_call/_gen/chalk/runtime/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chalk_remote_call/_gen/chalk/runtime/v1/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chalk_remote_call/_gen/chalk/runtime/v1/fnq_consumer_pb2.py,sha256=6MLRaTt0o7h6ASROnL6UxqkIkUbAunKrS_29CGtyKgg,6054
+chalk_remote_call/_gen/chalk/runtime/v1/fnq_consumer_pb2_grpc.py,sha256=d2kcgi9KeuqxzdKqwCB0TvatAM5aSvQsp-QcP2dXlbg,6600
+chalk_remote_call/_gen/chalk/runtime/v1/remote_python_call_pb2.py,sha256=Ccn5P1c-cXniPjij2DWpAclphY9VymQw4h0kM9QSBsY,14456
+chalk_remote_call/_gen/chalk/runtime/v1/remote_python_call_pb2_grpc.py,sha256=Vh5A-kEtmGEQqhJzNoReTnCFewEU4u_AXskKjQ6MEJA,18350
+chalk_remote_call/_gen/chalk/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chalk_remote_call/_gen/chalk/utils/v1/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chalk_remote_call/_gen/chalk/utils/v1/encoding_pb2.py,sha256=DSInrR0-LJCUjWBGcVLC20IFAtZaHAJ9GfrTK9eIKww,2309
+chalk_remote_call/_gen/chalk/utils/v1/encoding_pb2_grpc.py,sha256=_bXoS025FcWrXR1E_3Mh4GHB1RMvgz8lIpit-Awnf-s,163
+chalk_remote_call/_gen/chalk/utils/v1/field_change_pb2.py,sha256=usD4v-WPFQt8RYoIeT5ojn5LI6SYvP60bR7AbqyOm6k,2255
+chalk_remote_call/_gen/chalk/utils/v1/field_change_pb2_grpc.py,sha256=_bXoS025FcWrXR1E_3Mh4GHB1RMvgz8lIpit-Awnf-s,163
+chalk_remote_call/_gen/chalk/utils/v1/large_pb2.py,sha256=sqdkKqvj_xDR2M_epUpQ61zVMZW_BZErhpeSNz7euXM,1624
+chalk_remote_call/_gen/chalk/utils/v1/large_pb2_grpc.py,sha256=_bXoS025FcWrXR1E_3Mh4GHB1RMvgz8lIpit-Awnf-s,163
+chalk_remote_call/_gen/chalk/utils/v1/sensitive_pb2.py,sha256=6RSNPSmRSoFEpPdRNWqdNHNIlfbwHvFCMQiEUYk1vZs,1652
+chalk_remote_call/_gen/chalk/utils/v1/sensitive_pb2_grpc.py,sha256=_bXoS025FcWrXR1E_3Mh4GHB1RMvgz8lIpit-Awnf-s,163
+chalk_remote_call_python-1.10.5.dist-info/METADATA,sha256=KY_RevkkNNdSPu5sfY_7cgBm-ODlvUpnHtxjRYq7Z98,11425
+chalk_remote_call_python-1.10.5.dist-info/WHEEL,sha256=geuJoH1aW6kS7q0cKuoOBUdE-tpBsTvRf9l5rOGbxQs,101
+chalk_remote_call_python-1.10.5.dist-info/entry_points.txt,sha256=WoD51W5JhGXL2L0AOnVMuyemd200PcnuZtTbvKyYwmQ,65
+chalk_remote_call_python-1.10.5.dist-info/top_level.txt,sha256=7-CahbVI5EMhQktJ3IRLhTt03bmN93gfgRJX7zGyylc,18
+chalk_remote_call_python-1.10.5.dist-info/RECORD,,

chalk_remote_call_python-1.10.5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: false
+Tag: cp315-cp315-win_amd64
+

chalk_remote_call_python-1.10.5.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+chalk-remote-call = chalk_remote_call.cli:main

chalk_remote_call_python-1.10.5.dist-info/top_level.txt

@@ -0,0 +1 @@
+chalk_remote_call