chalkcompute 2.3.0__tar.gz → 2.3.2__tar.gz

{chalkcompute-2.3.0 → chalkcompute-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chalkcompute
-Version: 2.3.0
+Version: 2.3.2
 Requires-Dist: grpcio>=1.60.0
 Requires-Dist: protobuf>=4.25.0
 Requires-Dist: httpx>=0.25.0

{chalkcompute-2.3.0 → chalkcompute-2.3.2}/chalkcompute/__init__.py

@@ -45,6 +45,12 @@ _LAZY_MAP: dict[str, tuple[str, str]] = {
         "TracingPolicy",
     ),
     "function": ("chalkcompute._function", "function"),
+    # _remote_call_client.py
+    "RemoteCallClient": ("chalkcompute._remote_call_client", "RemoteCallClient"),
+    "RemoteCallClientUnavailable": (
+        "chalkcompute._remote_call_client",
+        "RemoteCallClientUnavailable",
+    ),
     # _model.py
     "bind_model": ("chalkcompute._model", "bind_model"),
     "ModelError": ("chalkcompute._model", "ModelError"),

{chalkcompute-2.3.0 → chalkcompute-2.3.2}/chalkcompute/__init__.pyi

@@ -37,6 +37,10 @@ from chalkcompute._model import ModelNotFoundError as ModelNotFoundError
 from chalkcompute._model import bind_model as bind_model
 from chalkcompute._quota import QueuePolicy as QueuePolicy
 from chalkcompute._rate_limit import RateLimitPolicy as RateLimitPolicy
+from chalkcompute._remote_call_client import RemoteCallClient as RemoteCallClient
+from chalkcompute._remote_call_client import (
+    RemoteCallClientUnavailable as RemoteCallClientUnavailable,
+)
 from chalkcompute._remote_function_tracing import TracingPolicy as TracingPolicy
 from chalkcompute._retry import RetryPolicy as RetryPolicy
 from chalkcompute._sandbox import ExecError as ExecError
@@ -105,6 +109,8 @@ __all__ = [
     "QueuePolicy",
     "TracingPolicy",
     "function",
+    "RemoteCallClient",
+    "RemoteCallClientUnavailable",
     "bind_model",
     "ModelError",
     "ModelNotFoundError",

{chalkcompute-2.3.0 → chalkcompute-2.3.2}/chalkcompute/_cls.py

@@ -74,6 +74,7 @@ from chalkcompute._function import (
     _make_base_image,
     _make_container_spec,
     _normalize_schedule,
+    _scaling_group_is_ready,
     _should_strip_source,
     _source_text_for_deploy,
     _write_temp,
@@ -1179,7 +1180,6 @@ class RemoteClass:
                 sg_data = data.get("scalingGroup")
                 web_url = sg_data.get("webUrl") if sg_data else None
                 port = sg_data.get("port", 6666) if sg_data else 6666
-                sg_status = sg_data.get("status", "") if sg_data else ""
 
                 # Build a RemoteFunction proxy for calling this method
                 rf = RemoteFunction._make_empty()
@@ -1198,17 +1198,24 @@ class RemoteClass:
                 )
                 progress_done(mkey)
 
-                if sg_status != "Running":
+                if not (
+                    sg_data
+                    and _scaling_group_is_ready(
+                        sg_data,
+                        require_ready_replicas=self._min_replicas > 0,
+                    )
+                ):
                     sg_names.append(version_info.scaling_group_name)
 
-            # 5. Poll scaling groups until running
+            # 5. Poll scaling groups until their backing pods can serve.
             if sg_names:
                 progress_update(ckey, detail="waiting for ready")
             for sg_name in sg_names:
-                self._poll_until_running(
+                self._poll_until_ready(
                     sg_name=sg_name,
                     poll_interval=poll_interval,
                     timeout=ready_timeout,
+                    require_ready_replicas=self._min_replicas > 0,
                 )
 
             self._deployed = True
@@ -1221,20 +1228,26 @@ class RemoteClass:
 
         return self
 
-    def _poll_until_running(
+    def _poll_until_ready(
         self,
         *,
         sg_name: str,
         poll_interval: float,
         timeout: float,
+        require_ready_replicas: bool = True,
     ) -> None:
         deadline = time.monotonic() + timeout
+        status = "unknown"
+        ready_replicas = 0
+        available_replicas = 0
         while time.monotonic() < deadline:
             resp = self._client.rpc(_SG_SVC, "GetScalingGroup", {"name": sg_name})
             if resp.status_code != 200:
                 raise ClassError(f"GetScalingGroup failed: {resp.text}")
             sg = resp.json()["scalingGroup"]
             status = sg.get("status", "")
+            ready_replicas = sg.get("readyReplicas", 0)
+            available_replicas = sg.get("availableReplicas", 0)
 
             # Update the web_url on the corresponding RemoteFunction
             web_url = sg.get("webUrl")
@@ -1247,13 +1260,25 @@ class RemoteClass:
                 ):
                     rf._web_url = web_url
 
-            logger.info("  poll %s: status=%s", sg_name, status)
-            if status in ("Running", "Available"):
+            logger.info(
+                "  poll %s: status=%s ready=%s available=%s",
+                sg_name,
+                status,
+                ready_replicas,
+                available_replicas,
+            )
+            if _scaling_group_is_ready(
+                sg, require_ready_replicas=require_ready_replicas
+            ):
                 return
             if status in ("Failed", "Error"):
                 raise ClassError(f"Scaling group {sg_name} entered {status} state")
             time.sleep(poll_interval)
-        raise ClassError(f"Scaling group {sg_name} timed out after {timeout}s")
+        raise ClassError(
+            f"Scaling group {sg_name} not ready after {timeout}s "
+            f"(status={status}, ready={ready_replicas}, "
+            f"available={available_replicas})"
+        )
 
     def wait_ready(
         self,

{chalkcompute-2.3.0 → chalkcompute-2.3.2}/chalkcompute/_function.py

@@ -95,7 +95,7 @@ F = TypeVar("F", bound=Callable[..., Any])
 _RemoteCallResult = TypeVar("_RemoteCallResult")
 KnowledgeCutoff = str | _dt.datetime
 
-_REMOTE_ENV_VAR = "_CHALK_REMOTE_FUNCTION"
+_REMOTE_ENV_VAR = "CHALK_REMOTE_FUNCTION"
 _REQUEST_TIMESTAMP_HEADER = "x-chalk-request-timestamp"
 _NO_ARGS_SENTINEL_COLUMN = "__chalk_no_args__"
 _LOCAL_COPY_ENV_VAR = _local_dev._LOCAL_COPY_ENV_VAR
@@ -461,6 +461,29 @@ def _has_running_event_loop() -> bool:
     return True
 
 
+def _replica_count(value: Any) -> int:
+    if value is None:
+        return 0
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return 0
+
+
+def _scaling_group_is_ready(
+    sg: dict[str, Any], *, require_ready_replicas: bool = True
+) -> bool:
+    status = sg.get("status", "")
+    if not require_ready_replicas:
+        return status in ("Running", "Available", "ScaledToZero")
+    if status not in ("Running", "Available"):
+        return False
+    return (
+        _replica_count(sg.get("readyReplicas")) > 0
+        and _replica_count(sg.get("availableReplicas")) > 0
+    )
+
+
 def _format_knowledge_cutoff(value: KnowledgeCutoff) -> str:
     if isinstance(value, str):
         if not value:
@@ -1996,10 +2019,8 @@ class RemoteFunction:
             if sg_data:
                 self._web_url = sg_data.get("webUrl")
                 self._port = sg_data.get("port", 6666)
-                sg_status = sg_data.get("status", "")
             else:
                 self._port = 6666
-                sg_status = ""
 
             logger.info(
                 "Function version created: %s v%s (id=%s)",
@@ -2009,13 +2030,20 @@ class RemoteFunction:
             )
             progress_done(rkey)
 
-            # 7. Poll scaling group until running
-            if sg_status != "Running":
+            # 7. Poll until the backing pod is actually ready to serve.
+            if not (
+                sg_data
+                and _scaling_group_is_ready(
+                    sg_data,
+                    require_ready_replicas=self._min_replicas > 0,
+                )
+            ):
                 progress_update(fkey, detail="waiting for ready")
-                self._poll_until_running(
+                self._poll_until_ready(
                     sg_name=self._version_info.scaling_group_name,
                     poll_interval=poll_interval,
                     timeout=ready_timeout,
+                    require_ready_replicas=self._min_replicas > 0,
                 )
 
             progress_done(fkey, detail="ready")
@@ -2033,14 +2061,19 @@ class RemoteFunction:
             extras.append("tracing")
         return _remote_call_runtime_package_with_extras(extras)
 
-    def _poll_until_running(
+    def _poll_until_ready(
         self,
         *,
         sg_name: str,
         poll_interval: float,
         timeout: float,
+        require_ready_replicas: bool = True,
     ) -> None:
         deadline = time.monotonic() + timeout
+        status = "unknown"
+        status_message = ""
+        ready_replicas = 0
+        available_replicas = 0
         while time.monotonic() < deadline:
             resp = self._client.rpc(
                 _SG_SVC,
@@ -2062,7 +2095,9 @@ class RemoteFunction:
                 available_replicas,
                 status_message or "",
             )
-            if status in ("Running", "Available"):
+            if _scaling_group_is_ready(
+                sg, require_ready_replicas=require_ready_replicas
+            ):
                 return
             if status in ("Failed", "Error"):
                 message = f"Scaling group {sg_name} entered {status} state"
@@ -2070,7 +2105,11 @@ class RemoteFunction:
                     message = f"{message}: {status_message}"
                 raise FunctionError(message)
             time.sleep(poll_interval)
-        message = f"Scaling group {sg_name} timed out after {timeout}s"
+        message = (
+            f"Scaling group {sg_name} not ready after {timeout}s "
+            f"(status={status}, ready={ready_replicas}, "
+            f"available={available_replicas})"
+        )
         if status_message:
             message = f"{message}: {status_message}"
         raise FunctionError(message)
@@ -2114,9 +2153,7 @@ class RemoteFunction:
             self._web_url = sg.get("webUrl")
             if status in ("Failed", "Error"):
                 raise FunctionError(f"Scaling group {sg_name} entered {status} state")
-            ready = sg.get("readyReplicas", 0)
-            available = sg.get("availableReplicas", 0)
-            if status in ("Running", "Available") and ready > 0 and available > 0:
+            if _scaling_group_is_ready(sg):
                 return self
             time.sleep(poll_interval)
 

{chalkcompute-2.3.0 → chalkcompute-2.3.2}/chalkcompute/_image.py

@@ -43,6 +43,11 @@ _ARCHIVE_CHUNK_PREFIX = "_archive.part."
 # PutFile payload is base64-encoded, so keep raw chunks under ~6 MB
 # to stay well within typical HTTP body limits after encoding (~8 MB).
 _ARCHIVE_CHUNK_SIZE = 6 * 1024 * 1024
+# Copy content is base64-embedded into the image spec and generated Dockerfile.
+# A 32 KiB raw budget stays under Argo object-size pressure after encoding and
+# leaves headroom under Kaniko's 65,535-byte Dockerfile line limit.
+_COPY_FILE_SIZE_LIMIT_BYTES = 32 * 1024
+_COPY_TOTAL_SIZE_LIMIT_BYTES = 32 * 1024
 
 
 @dataclass(frozen=True)
@@ -388,7 +393,9 @@ class Image:
             - ``0o400`` (``r--------``) — immutable/read-only files the
               workload must not mutate.
         strategy
-            ``"copy"`` inlines the file contents into the image spec.
+            ``"copy"`` inlines the file contents into the image spec and
+            rejects files larger than 32 KiB or additions that would make
+            the image's total copied content exceed 32 KiB.
             ``"volume"`` (default) defers the file as a lazy reference
             to be mounted at sandbox start.
 
@@ -397,6 +404,12 @@ class Image:
         Image
             A new ``Image`` with the file registered for inclusion.
 
+        Raises
+        ------
+        ValueError
+            If ``strategy="copy"`` exceeds the per-file or total copied-content
+            limit.
+
         Examples
         --------
         >>> from chalkcompute import Image
@@ -429,7 +442,13 @@ class Image:
                 LazyLocalFile(src=str(src_path), dest=dest, mode=mode)
             )
         else:
-            content = Path(src).read_bytes()
+            src_path = Path(src)
+            content = _read_copy_file(src_path)
+            _validate_copy_total_size(
+                current_size=_inline_copy_size(new._steps),
+                added_size=len(content),
+                path=src_path,
+            )
             step = pb.AddFileStep(destination=dest, content=content)
             if mode is not None:
                 step.mode = mode
@@ -464,7 +483,9 @@ class Image:
         dest
             Absolute destination directory in the image.
         strategy
-            ``"copy"`` inlines all file contents into the image spec.
+            ``"copy"`` inlines all file contents into the image spec and
+            rejects files larger than 32 KiB or additions that would make
+            the image's total copied content exceed 32 KiB.
             ``"volume"`` (default) defers each file as a lazy reference
             to be mounted at sandbox start.
         exclude
@@ -481,6 +502,12 @@ class Image:
         Image
             A new ``Image`` with the directory registered for inclusion.
 
+        Raises
+        ------
+        ValueError
+            If ``strategy="copy"`` exceeds the per-file or total copied-content
+            limit.
+
         Examples
         --------
         >>> from chalkcompute import Image
@@ -548,6 +575,7 @@ class Image:
                     )
             return new
 
+        copy_size = _inline_copy_size(new._steps)
         for file_path in _iter_files():
             rel = file_path.relative_to(src_path)
             file_dest = os.path.join(dest, str(rel))
@@ -558,7 +586,12 @@ class Image:
                     )
                 )
             else:
-                content = file_path.read_bytes()
+                content = _read_copy_file(file_path)
+                copy_size = _validate_copy_total_size(
+                    current_size=copy_size,
+                    added_size=len(content),
+                    path=file_path,
+                )
                 new._steps.append(
                     pb.BuildStep(
                         add_file=pb.AddFileStep(destination=file_dest, content=content)
@@ -856,3 +889,48 @@ def _validate_lazy_local_file_destination(
             "Use strategy='copy' or place files under a subdirectory "
             "(for example '/app/app.py')."
         )
+
+
+def _read_copy_file(path: Path) -> bytes:
+    """Read a file only when its actual content fits the copy-file budget."""
+    with path.open("rb") as file:
+        content = file.read(_COPY_FILE_SIZE_LIMIT_BYTES + 1)
+    if len(content) > _COPY_FILE_SIZE_LIMIT_BYTES:
+        raise ValueError(
+            f"{path} is at least {len(content)} bytes, which exceeds the "
+            f"{_format_size_limit(_COPY_FILE_SIZE_LIMIT_BYTES)} per-file limit "
+            "for strategy='copy'. "
+            "Use strategy='volume' for larger files."
+        )
+    return content
+
+
+def _inline_copy_size(steps: Sequence[pb.BuildStep]) -> int:
+    """Return the raw bytes already embedded by copy-based add-file steps."""
+    return sum(
+        len(step.add_file.content)
+        for step in steps
+        if step.WhichOneof("step") == "add_file"
+    )
+
+
+def _validate_copy_total_size(*, current_size: int, added_size: int, path: Path) -> int:
+    """Return the new copied-content size or reject an oversized image spec."""
+    total_size = current_size + added_size
+    if total_size > _COPY_TOTAL_SIZE_LIMIT_BYTES:
+        raise ValueError(
+            f"adding {path} would inline {total_size} bytes, which exceeds the "
+            f"{_format_size_limit(_COPY_TOTAL_SIZE_LIMIT_BYTES)} total limit "
+            "for strategy='copy'. "
+            "Use strategy='volume' for larger files or directories."
+        )
+    return total_size
+
+
+def _format_size_limit(size: int) -> str:
+    """Format a byte limit using the largest exact binary unit."""
+    if size % (1024 * 1024) == 0:
+        return f"{size // (1024 * 1024)} MiB"
+    if size % 1024 == 0:
+        return f"{size // 1024} KiB"
+    return f"{size} bytes"

{chalkcompute-2.3.0 → chalkcompute-2.3.2}/chalkcompute/_local_dev.py

@@ -38,7 +38,7 @@ _LOCAL_SDK_RUNTIME_PACKAGES = [
 
 
 def running_in_function_pod() -> bool:
-    return bool(os.environ.get("_CHALK_REMOTE_FUNCTION"))
+    return bool(os.environ.get("CHALK_REMOTE_FUNCTION"))
 
 
 def build_function_runtime_image(*, python_version: str = "3.11") -> object:

{chalkcompute-2.3.0 → chalkcompute-2.3.2}/chalkcompute/_remote_call_client.py

@@ -7,6 +7,7 @@ import importlib.machinery
 import importlib.util
 import logging
 import sys
+import time
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Sequence
@@ -155,6 +156,7 @@ class RemoteCallClient:
             auth_rpc_timeout_ms,
             auth_retry_interval_ms,
         )
+        start = time.monotonic()
         try:
             self._inner = _NativeRemoteCallClient(
                 endpoint,
@@ -191,6 +193,12 @@ class RemoteCallClient:
         self._supports_per_call_metadata: bool = (
             self._detect_per_call_metadata_support()
         )
+        logger.debug(
+            "RemoteCallClient connected endpoint=%s use_tls=%s elapsed_ms=%.1f",
+            endpoint,
+            use_tls,
+            (time.monotonic() - start) * 1000,
+        )
 
     def _inner_or_raise(self) -> Any:
         if self._closed:
@@ -238,11 +246,21 @@ class RemoteCallClient:
         input_ipc: bytes,
         metadata: Sequence[tuple[str, str]] = (),
     ) -> list[bytes]:
+        start = time.monotonic()
         if metadata and self._supports_per_call_metadata:
-            return list(
+            chunks = list(
                 self._inner_or_raise().call_ipc(name, input_ipc, list(metadata))
             )
-        return list(self._inner_or_raise().call_ipc(name, input_ipc))
+        else:
+            chunks = list(self._inner_or_raise().call_ipc(name, input_ipc))
+        logger.debug(
+            "RemoteCallClient call_ipc function=%s request_bytes=%d chunks=%d elapsed_ms=%.1f",
+            name,
+            len(input_ipc),
+            len(chunks),
+            (time.monotonic() - start) * 1000,
+        )
+        return chunks
 
     def enqueue(
         self,
@@ -250,9 +268,20 @@ class RemoteCallClient:
         input_ipc: bytes,
         metadata: Sequence[tuple[str, str]] = (),
     ) -> str:
+        start = time.monotonic()
         if metadata and self._supports_per_call_metadata:
-            return str(self._inner_or_raise().enqueue(name, input_ipc, list(metadata)))
-        return str(self._inner_or_raise().enqueue(name, input_ipc))
+            call_id = str(
+                self._inner_or_raise().enqueue(name, input_ipc, list(metadata))
+            )
+        else:
+            call_id = str(self._inner_or_raise().enqueue(name, input_ipc))
+        logger.debug(
+            "RemoteCallClient enqueue function=%s request_bytes=%d elapsed_ms=%.1f",
+            name,
+            len(input_ipc),
+            (time.monotonic() - start) * 1000,
+        )
+        return call_id
 
     def poll_next(
         self,
@@ -260,8 +289,9 @@ class RemoteCallClient:
         cursor: str = "",
         poll_count: int = 0,
     ) -> RemoteCallPollResult:
+        start = time.monotonic()
         raw = self._inner_or_raise().poll_next(call_id, cursor, poll_count)
-        return RemoteCallPollResult(
+        result = RemoteCallPollResult(
             status=int(raw["status"]),
             status_name=str(raw["status_name"]),
             chunks=list(raw["chunks"]),
@@ -269,6 +299,14 @@ class RemoteCallClient:
             error_message=raw["error_message"],
             poll_count=int(raw["poll_count"]),
         )
+        logger.debug(
+            "RemoteCallClient poll_next call_id=%s status=%s chunks=%d elapsed_ms=%.1f",
+            call_id,
+            result.status_name,
+            len(result.chunks),
+            (time.monotonic() - start) * 1000,
+        )
+        return result
 
     def get_result_chunks(self, call_id: str) -> list[bytes]:
         return list(self._inner_or_raise().get_result_chunks(call_id))

{chalkcompute-2.3.0 → chalkcompute-2.3.2}/chalkcompute/_scaling_group.py

@@ -293,7 +293,8 @@ class ScalingGroup:
         build_timeout
             Maximum seconds to wait for the image build to complete.
         ready_timeout
-            Maximum seconds to wait for the scaling group to reach ``Running``.
+            Maximum seconds to wait for the scaling group to have at least one
+            ready and available replica.
 
         Returns
         -------
@@ -420,23 +421,29 @@ class ScalingGroup:
             self._scaling_group_info.status,
         )
 
-        # 4. Poll until Running
-        if self._scaling_group_info.status != "Running":
-            self._poll_until_running(
+        # 4. Poll until the backing pod is actually ready to serve.
+        if not _scaling_group_info_is_ready(
+            self._scaling_group_info,
+            require_ready_replicas=self._min_replicas > 0,
+        ):
+            self._poll_until_ready(
                 poll_interval=poll_interval,
                 timeout=ready_timeout,
+                require_ready_replicas=self._min_replicas > 0,
             )
 
         return self
 
-    def _poll_until_running(
+    def _poll_until_ready(
         self,
         *,
         poll_interval: float,
         timeout: float,
+        require_ready_replicas: bool = True,
     ) -> None:
         assert self._scaling_group_id is not None
         deadline = time.monotonic() + timeout
+        info = self._scaling_group_info
         while time.monotonic() < deadline:
             resp = self._client.rpc(
                 _SVC, "GetScalingGroup", {"id": self._scaling_group_id}
@@ -445,16 +452,28 @@ class ScalingGroup:
                 raise ScalingGroupError(f"GetScalingGroup failed: {resp.text}")
             info = _parse_scaling_group_response(resp.json()["scalingGroup"])
             self._scaling_group_info = info
-            logger.info("  poll: status=%s", info.status)
-            if info.status in ("Running", "Available"):
+            logger.info(
+                "  poll: status=%s ready=%s available=%s",
+                info.status,
+                info.ready_replicas,
+                info.available_replicas,
+            )
+            if _scaling_group_info_is_ready(
+                info,
+                require_ready_replicas=require_ready_replicas,
+            ):
                 return
             if info.status in ("Failed", "Error"):
                 raise ScalingGroupError(
                     f"Scaling group {self._scaling_group_id} entered {info.status} state"
                 )
             time.sleep(poll_interval)
+        status = info.status if info else "unknown"
+        ready = info.ready_replicas if info else 0
+        available = info.available_replicas if info else 0
         raise ScalingGroupError(
-            f"Scaling group {self._scaling_group_id} timed out after {timeout}s"
+            f"Scaling group {self._scaling_group_id} not ready after {timeout}s "
+            f"(status={status}, ready={ready}, available={available})"
         )
 
     @_instrumented("chalkcompute.scaling_group.call")
@@ -542,11 +561,7 @@ class ScalingGroup:
                 raise ScalingGroupError(
                     f"Scaling group {self._scaling_group_id} entered {info.status} state"
                 )
-            if (
-                info.status in ("Running", "Available")
-                and info.ready_replicas > 0
-                and info.available_replicas > 0
-            ):
+            if _scaling_group_info_is_ready(info):
                 return self
             time.sleep(poll_interval)
 
@@ -639,3 +654,13 @@ def _parse_scaling_group_response(data: dict) -> ScalingGroupInfo:
         ready_replicas=data.get("readyReplicas", 0),
         available_replicas=data.get("availableReplicas", 0),
     )
+
+
+def _scaling_group_info_is_ready(
+    info: ScalingGroupInfo, *, require_ready_replicas: bool = True
+) -> bool:
+    if not require_ready_replicas:
+        return info.status in ("Running", "Available", "ScaledToZero")
+    if info.status not in ("Running", "Available"):
+        return False
+    return info.ready_replicas > 0 and info.available_replicas > 0

{chalkcompute-2.3.0 → chalkcompute-2.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "chalkcompute"
-version = "2.3.0"
+version = "2.3.2"
 description = "SDK for Chalk sandboxes, containers, and volumes"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"