sequence-base 0.3.16__tar.gz → 0.3.18__tar.gz

{sequence_base-0.3.16 → sequence_base-0.3.18}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.5
 Name: sequence-base
-Version: 0.3.16
+Version: 0.3.18
 Summary: Shared foundation for the Sequences platform — wire contract, correlation, error taxonomy, constants. Used by the robot SDK, gateway, and container harness.
-Requires-Python: >=3.11
+Requires-Python: >=3.10
 Requires-Dist: pydantic>=2.0
 Provides-Extra: codec
 Requires-Dist: numpy>=1.26; extra == 'codec'

{sequence_base-0.3.16 → sequence_base-0.3.18}/README.md

@@ -34,5 +34,5 @@ values (per-model client_resize, pricing, licensing) stay out — in container /
 `pip install -e .` (core = pydantic). The image codec pulls PIL/numpy, so it is an optional extra —
 `pip install -e ".[codec]"` — which the gateway (which never encodes/decodes) skips.
 
-Extracted from `general-sequences/backend/sequences/` (`api/schema.py`, `obs.py`,
-`api/handoff/runpod.py`). Renamed from `sequence-contract` once it grew past just the contract.
+Extracted from the original backend's schema and observability modules. Renamed from `sequence-contract` once it
+grew past just the contract.

{sequence_base-0.3.16 → sequence_base-0.3.18}/pyproject.toml

@@ -1,8 +1,10 @@
 [project]
 name = "sequence-base"
-version = "0.3.16"
+version = "0.3.18"
 description = "Shared foundation for the Sequences platform — wire contract, correlation, error taxonomy, constants. Used by the robot SDK, gateway, and container harness."
-requires-python = ">=3.11"
+# 3.10, not 3.11: `seq` (which imports this) must run on ROS 2 Humble's Python 3.10, and nothing here needs 3.11.
+# {2026-10-03 the full suite on CPython 3.10.20: "147 PASSED"; vermin --eval-annotations: "MINIMUM REQUIRED VERSIONS: 3.9"}
+requires-python = ">=3.10"
 dependencies = ["pydantic>=2.0"]
 
 # codec (image encode/decode) is P1 and pulls PIL/numpy — an optional extra so the gateway, which

{sequence_base-0.3.16 → sequence_base-0.3.18}/sequence_base/__init__.py

@@ -14,6 +14,10 @@ catalogue values stay in container / gateway / spec.py.
 # contract — the full shared wire contract (obs/action + registry + deployments + connect + eval +
 # accounts + error bodies). One definition per shape; see sequence_base/contract for the grouping.
 from sequence_base.contract import (  # noqa: F401  (re-export surface)
+    ActRequest,
+    ActResponse,
+    AddLocal,
+    ImageStepAddLocal,
     Camera,
     Embodiment,
     ObservationContract,
@@ -112,8 +116,6 @@ from sequence_base.errors.transport import (
 # auth — Bearer secret helpers (gateway direct-connect / internal; container guard; worker emit)
 from sequence_base import auth
 
-# telemetry — cold-start event schema (worker emits, gateway ingests)
-from sequence_base.telemetry.events import WorkerLogEvent
 
 # NOTE: codec (image encode/decode) is intentionally NOT re-exported here — it needs PIL + numpy
 # (the [codec] extra), and the gateway installs the light core. Import it explicitly where needed:
@@ -122,8 +124,10 @@ from sequence_base.telemetry.events import WorkerLogEvent
 __all__ = [
     # contract 4 — /act data plane
     "ImageFrame", "Proprioception", "Observation", "ActionSpace", "ActionStep", "ActionChunk",
+    "ActRequest", "ActResponse",
     # contract 1 — flags + policy registry
-    "SeqFlags", "ImageStepUvPip", "ImageStepApt", "ImageStepEnv", "ImageStepRun", "ImageStep", "ImageSpec",
+    "SeqFlags", "ImageStepUvPip", "ImageStepApt", "ImageStepEnv", "ImageStepRun", "AddLocal", "ImageStepAddLocal",
+    "ImageStep", "ImageSpec",
     "VolumeMount", "VolumeRef", "Concurrency", "ActionContract", "Camera", "ObservationContract", "Embodiment",
     "PolicySpec", "PolicyRegistration",
     # contract 2 — deployments
@@ -150,7 +154,14 @@ __all__ = [
     # errors (exception taxonomy)
     "TransportUnavailable", "TransportWarming", "TransportRejected", "TransportOverloaded",
     # auth + telemetry
-    "auth", "WorkerLogEvent",
+    "auth",
 ]
 
-__version__ = "0.3.6"
+try:
+    # The installed distribution's own number, so this can never drift from pyproject.toml again (it said 0.3.6
+    # while the package was 0.3.12). A source tree that was never installed reports "dev".
+    from importlib.metadata import PackageNotFoundError, version as _version
+
+    __version__ = _version("sequence-base")
+except PackageNotFoundError:  # pragma: no cover - running from an uninstalled checkout
+    __version__ = "dev"

sequence_base-0.3.18/sequence_base/codec/__init__.py

@@ -0,0 +1,19 @@
+"""
+Image codec — the frame <-> wire transform, shared so the SDK (encode) and the worker (decode) cannot drift
+on the wire format.
+
+Needs Pillow + numpy: `pip install 'sequence-base[codec]'`. The gateway, which neither encodes nor
+decodes, installs the light core and never imports this.
+
+    from sequence_base.codec import encode, decode
+"""
+from sequence_base.codec.image import (
+    DEFAULT_JPEG_QUALITY,
+    MAX_UPLOAD_EDGE,
+    decode,
+    decode_depth,
+    encode,
+    encode_depth,
+)
+
+__all__ = ["encode", "decode", "encode_depth", "decode_depth", "DEFAULT_JPEG_QUALITY", "MAX_UPLOAD_EDGE"]

{sequence_base-0.3.16 → sequence_base-0.3.18}/sequence_base/codec/image.py

@@ -15,7 +15,6 @@ import base64
 import io
 from typing import Any
 
-from .resize import MAX_UPLOAD_EDGE, ResizeSpec, filters, refuse_wrong_aspect, resize_with_pad
 
 # Quality 95, and the number is measured rather than chosen for looking safe. On a real DROID frame
 # with the sampling noise pinned, the encoding moves the resulting action by: q95 0.51% of action
@@ -25,20 +24,22 @@ from .resize import MAX_UPLOAD_EDGE, ResizeSpec, filters, refuse_wrong_aspect, r
 # {sequences-models models/pi05_droid/handler.py "Q95 MAX|DELTA| 0.0048 0.51% ... Q85 1.86%"}
 DEFAULT_JPEG_QUALITY = 95
 
+# The longest edge `encode` uploads. Every policy resizes a frame to its own input size anyway, so pixels above
+# that only cost transport — and past a point they do not cost, they fail: a body over ~2 MB was dropped by a
+# worker queue with no error and no job id, surfacing as a hang. 640 is above every input size in use (pi0.5's
+# 224), so it discards nothing a policy reads. [MEASURED 2026-09-12: capping the long edge at 640 took a
+# three-view observation from 1.98 MB to 0.12 MB]
+MAX_UPLOAD_EDGE = 640
 
-def encode(frame: Any, spec: ResizeSpec | None = None, *, quality: int = DEFAULT_JPEG_QUALITY) -> str:
+
+def encode(frame: Any, *, quality: int = DEFAULT_JPEG_QUALITY) -> str:
     """
     One camera frame to the base64 image that `ImageFrame.data` carries.
 
     `frame` may be a numpy array, a PIL image, raw `bytes` already encoded, or a `str` already base64
     — the last two pass through untouched, so a caller with their own pipeline is not forced through
-    this one.
-
-    `spec` (a `ResizeSpec`) carries the model's geometry. When it declares a training aspect ratio, a
-    frame outside it is REFUSED — see `refuse_wrong_aspect`, not quietly reshaped. With no spec (or no
-    `client_resize`) the frame falls to `MAX_UPLOAD_EDGE`. Codec is JPEG at `quality`, unconditionally
-    — every served handler asks for JPEG in as many words, so there is no size probe and no second
-    encode. {handlers pi05_droid/cosmos3/groot all "SEND BASE64 JPEG"}
+    this one. A frame whose long edge is over `MAX_UPLOAD_EDGE` is scaled down to it first. Codec is
+    JPEG at `quality`, unconditionally.
     """
     if isinstance(frame, str):
         return frame
@@ -56,59 +57,7 @@ def encode(frame: Any, spec: ResizeSpec | None = None, *, quality: int = DEFAULT
     img = frame if hasattr(frame, "save") else Image.fromarray(frame)
     if img.mode != "RGB":
         img = img.convert("RGB")
-
-    # Downscale before encoding. Every model resizes the frame to its own input size anyway, so pixels
-    # above that only cost transport — and past a point they do not cost, they fail (a body over ~2 MB
-    # is dropped by the worker queue with no error and no job id, surfacing as a hang). The target and
-    # the filter both come from the spec; neither is derived here. `client_resize=None` means the
-    # model declined pre-resizing and is not a gap: it falls to the cap below, as an unknown model
-    # does. HOW the frame reaches that size comes from `input_resize` ("pad" = the server's own
-    # resize_with_pad, "stretch" = unconditional interpolate).
-    want = None
-    cr = spec.client_resize if spec else None
-    if cr:
-        # `shortest_edge` scales the short side to n and lets the ratio follow — the only way to
-        # express a server step defined as "SmallestMaxSize(256)" (1280x720 and 1920x1080 both to
-        # 455x256), which no fixed [w, h] covers. round(), matching albumentations. `size` is a fixed
-        # target.
-        if "shortest_edge" in cr:
-            # Shrink only. SmallestMaxSize also UPSCALES a frame whose short edge is under the target,
-            # and reproducing that here is strictly worse: the payload grows and the upscale happens
-            # in PIL when the server was going to do it in cv2 anyway. Leaving a small frame alone
-            # hands the whole operation to the server, where it is exact.
-            n = int(cr["shortest_edge"])
-            if min(img.size) > n:
-                scale = n / min(img.size)
-                want = (max(1, round(img.width * scale)), max(1, round(img.height * scale)))
-            else:
-                want = img.size
-        else:
-            want = (int(cr["size"][0]), int(cr["size"][1]))
-        if img.size != want:
-            # The filter is named by the server, not chosen here: this resize stands in for one the
-            # model's own transform would otherwise run, so it has to be the SAME operation. An
-            # unrecognised name raises rather than falling back — a silent default is how the LANCZOS
-            # bug shipped. {MEASURED: BILINEAR to pi05's content block is 0.000/255, LANCZOS 0.779/15}
-            try:
-                resample = filters()[cr["filter"]]
-            except KeyError:
-                raise ValueError(
-                    f"{spec.label} asks for resize filter {cr['filter']!r}, which this version of "
-                    f"sequence-base does not implement (has: {sorted(filters())}). Upgrade, or pass "
-                    f"an already-encoded frame to bypass this step."
-                ) from None
-            # Refused before either branch, not inside "pad": a stretch model distorts a wrong ratio
-            # instead of letterboxing it, which is worse rather than exempt.
-            refuse_wrong_aspect(img, spec.aspect_ratio, max(want), spec.label)
-            if "shortest_edge" in cr:
-                # Already proportional, so nothing to letterbox — and letterboxing would actively
-                # damage it (a spurious black row the server carries into its crop as if it were scene).
-                img = img.resize(want, resample)
-            elif (spec.input_resize or "pad") == "pad":
-                img = resize_with_pad(img, want[0], want[1], resample)
-            else:
-                img = img.resize(want, resample)
-    elif max(img.size) > MAX_UPLOAD_EDGE:
+    if max(img.size) > MAX_UPLOAD_EDGE:
         scale = MAX_UPLOAD_EDGE / max(img.size)
         # round() not int(): int() truncates a 640.9 on one axis and 359.9 on the other, drifting the
         # aspect ratio by up to half a percent for no reason.

{sequence_base-0.3.16 → sequence_base-0.3.18}/sequence_base/constants/env.py

@@ -5,10 +5,3 @@ INTERNAL_SECRET = "SEQ_INTERNAL_SECRET"  # auth for container → gateway teleme
 GATEWAY_URL = "SEQ_GATEWAY_URL"          # where the container sends telemetry
 VOLUME_ROOT = "SEQ_VOLUME_ROOT"          # where fetched weights land
 MANIFEST = "SEQ_MANIFEST"                # the policy manifest a container serves
-
-# Weight store (Cloudflare R2).
-DIST_ENDPOINT = "SEQ_DIST_ENDPOINT"
-DIST_BUCKET = "SEQ_DIST_BUCKET"
-DIST_KEY = "SEQ_DIST_KEY"
-DIST_SECRET = "SEQ_DIST_SECRET"
-DIST_REGION = "SEQ_DIST_REGION"

{sequence_base-0.3.16 → sequence_base-0.3.18}/sequence_base/constants/headers.py

@@ -1,5 +1,4 @@
 """HTTP header names — one source, so sdk / gateway / container never spell them differently."""
 
 REQUEST_ID = "X-Seq-Request-Id"   # correlation id; == sequence_base.obs.rid.HEADER
-MODEL = "X-Seq-Model"             # gateway → worker model routing
 AUTH_SCHEME = "Bearer"            # scheme for SEQ_DIRECT_SECRET on the direct-connect path

{sequence_base-0.3.16 → sequence_base-0.3.18}/sequence_base/constants/version.py

@@ -4,7 +4,9 @@
 # across deployments / repos can tell which version of a shape it is validating against. MUST change
 # whenever any shared wire shape changes (a field added / removed / retyped) — that is what makes
 # contract evolution mechanically detectable instead of eyeballed. Bump on any shape change.
-CONTRACT_VERSION = "0.4.13"  # 0.4.12 -> 0.4.13: template://<name>[@v<n>] — official template weights (parse_template); gs:// / s3:// / https:// still accepted until their removal
+CONTRACT_VERSION = "0.4.15"  # 0.4.14 -> 0.4.15: limits count GPUs and CPU/memory are billed like Modal — Resources.cpu / memory_gb optional floats + cpu_limit / memory_limit_gb; Autoscaler.max_gpus / on_full / queue_timeout_s replace max_containers; Concurrency fields optional + replicas_per_gpu / gpus_per_replica; DeploymentStatusResponse.reason; EvalRequest.policy_instances / policy_gpu / benchmark_instances / benchmark_gpu / envs replace gpus / envs_per_gpu; EvalStatus.QUEUED; EvalCards / EvalQueue
+# previous: 0.4.14  # 0.4.13 -> 0.4.14: the /act wire is opaque (ActRequest.inputs / ActResponse.outputs); action / observation contracts optional + DeploymentPolicy/PolicySpec/ConnectResponse .io; the robot-arm types live in sequence_base.presets.robot_arm (contract.act / contract.io re-export them); ImageStepAddLocal (seq.Image.add_local_*); ActionSpace.JOINT_VELOCITY (pi0.5 DROID's joint velocities + gripper position)
+# previous: 0.4.13  # 0.4.12 -> 0.4.13: template://<name>[@v<n>] — official template weights (parse_template); gs:// / s3:// / https:// still accepted until their removal
 # previous: 0.4.12  # 0.4.11 -> 0.4.12: one error definition — ErrorBody is every non-2xx body (detail, code, retryable, retry_after_s, request_id, hint, details), ErrorCode covers every case, ERRORS / ErrorCodes.json give each code its status, retryability, SDK class and CLI exit code
 # previous: 0.4.11  # 0.4.10 -> 0.4.11: weights in named parts (weights_name, extra_weights)
 # previous: 0.4.8  # 0.4.7 -> 0.4.8: ImageSpec.python, ImageStepRun.secrets, Resources.region, DeploymentRequest/BenchmarkRegisterRequest.image_context

{sequence_base-0.3.16 → sequence_base-0.3.18}/sequence_base/contract/__init__.py

@@ -12,6 +12,9 @@ from sequence_base.contract.act import (
     Proprioception,
 )
 
+# contract 4, version 2 — the opaque /act envelope (inputs in, outputs out)
+from sequence_base.contract.wire import ActRequest, ActResponse
+
 # contract 1 — lifecycle flags + policy registry
 from sequence_base.contract.flags import SeqFlags
 from sequence_base.contract.policy import (
@@ -26,6 +29,8 @@ from sequence_base.contract.policy import (
     ImageStepEnv,
     ImageStepRun,
     ImageStepUvPip,
+    AddLocal,
+    ImageStepAddLocal,
     PolicyRegistration,
     PolicySpec,
     VolumeMount,
@@ -110,9 +115,11 @@ from sequence_base.contract.errors import ERRORS, ErrorBody, ErrorCode, ErrorSpe
 __all__ = [
     # contract 4
     "ImageFrame", "Proprioception", "Observation", "ActionSpace", "ActionStep", "ActionChunk",
+    "ActRequest", "ActResponse",
     # contract 1
     "SeqFlags",
-    "ImageStepUvPip", "ImageStepApt", "ImageStepEnv", "ImageStepRun", "ImageStep", "ImageSpec",
+    "ImageStepUvPip", "ImageStepApt", "ImageStepEnv", "ImageStepRun", "AddLocal", "ImageStepAddLocal", "ImageStep",
+    "ImageSpec",
     "VolumeMount", "VolumeRef", "Concurrency", "ActionContract", "Camera", "ObservationContract", "Embodiment",
     "PolicySpec", "PolicyRegistration",
     # contract 2

sequence_base-0.3.18/sequence_base/contract/act.py

@@ -0,0 +1,17 @@
+"""
+The robot-arm /act data types, re-exported from their home in `sequence_base.presets.robot_arm`.
+
+They are no longer the platform's wire: since contract 0.4.14 the worker passes a policy's `inputs` through untouched
+(`sequence_base.contract.wire`). This module keeps `from sequence_base.contract.act import Observation` resolving to the
+same classes for the gateway, harness and SDK code that still uses the preset.
+"""
+from sequence_base.presets.robot_arm import (  # noqa: F401 — re-exports
+    ActionChunk,
+    ActionSpace,
+    ActionStep,
+    ImageFrame,
+    Observation,
+    Proprioception,
+)
+
+__all__ = ["ImageFrame", "Proprioception", "Observation", "ActionSpace", "ActionStep", "ActionChunk"]

{sequence_base-0.3.16 → sequence_base-0.3.18}/sequence_base/contract/connect.py

@@ -57,3 +57,5 @@ class ConnectResponse(BaseModel):
     action: ActionContract | None = None
     observation: ObservationContract | None = None
     embodiment: str | None = None
+    # The deployment's own description of its inputs and outputs (DeploymentPolicy.io), when the author wrote one.
+    io: str | None = None

{sequence_base-0.3.16 → sequence_base-0.3.18}/sequence_base/contract/deployments.py

@@ -1,8 +1,8 @@
 """
 契约 2 — `POST /v1/deployments` (SDK `seq deploy` → gateway) and its responses.
 
-The request is the normalized wire form of a PolicySpec: one big body (à la Modal's single `Function`
-message — new config adds a field, never a new endpoint) whose sub-shapes reuse contract 1's types
+The request is the normalized wire form of a PolicySpec: one big body (new config adds a field, never a
+new endpoint) whose sub-shapes reuse contract 1's types
 (ImageSpec, VolumeMount, Concurrency, ActionContract). Field names align with the PolicySpec side —
 `gpu` is normalized to list[str] here, the memory field is `memory_gb` (goal 7).
 
@@ -47,27 +47,48 @@ __all__ = [
 
 
 class Resources(BaseModel):
-    """= Modal Resources + GPUConfig. `gpu` is list[str] (the PolicySpec `str | list[str]` normalized)."""
+    """The hardware a worker runs on. `gpu` is list[str] (the PolicySpec `str | list[str]` normalized)."""
 
     model_config = ConfigDict(extra="forbid")
 
     gpu: list[str]
-    cpu: int
-    memory_gb: int
+    # Physical cores and GiB the worker requests, billed like Modal: per second, at the greater of the request and what
+    # it uses. None requests the minimum (0.125 cores, 0.125 GiB) and the worker may use more. A limit caps what it may
+    # use; None leaves it free to burst. {gs-plans/parallel/cpu-memory.md "4. 默认申请量照 Modal"}
+    cpu: float | None = Field(default=None, ge=0.125, le=64)
+    cpu_limit: float | None = Field(default=None, ge=0.125, le=128)
+    memory_gb: float | None = Field(default=None, ge=0.125, le=1024)
+    memory_limit_gb: float | None = Field(default=None, ge=0.125, le=1024)
     # Where the workers run (near the robots): one of the regions the platform offers. None: the platform picks.
     # {gs-plans/customization/policy.md "区域"}
     region: str | None = Field(default=None, max_length=32)
 
+    @model_validator(mode="after")
+    def _limits_cover_requests(self) -> "Resources":
+        for what, req, lim in (("cpu", self.cpu, self.cpu_limit), ("memory", self.memory_gb, self.memory_limit_gb)):
+            if req is not None and lim is not None and lim < req:
+                raise ValueError(f"the {what} limit must be at least the {what} request")
+        return self
+
 
 class Autoscaler(BaseModel):
-    """= Modal AutoscalerSettings. Defaults mirror PolicySpec so an omitted block scale-to-zeroes."""
+    """How the deployment scales. Defaults mirror PolicySpec so an omitted block scales to zero."""
 
     model_config = ConfigDict(extra="forbid")
 
     min_containers: int = 0
+    # Accepted and ignored: limits count GPUs (`max_gpus`). sequence-ai <= 0.28 still sends it and does not pin
+    # sequence-base, so removing it would break their deploys; it goes when no supported SDK sends it.
     max_containers: int | None = None
+    # The most GPUs this deployment may hold at once. None: no cap of its own — only the account's and the platform's
+    # GPU limits bound it. Limits count cards, never machines. {gs-plans/parallel/serving.md "1. 限制按卡数,不按台数"}
+    max_gpus: int | None = Field(default=None, ge=1, le=256)
     buffer_containers: int | None = None
     scaledown_window: int = 600
+    # When every slot is taken and no card is left: queue the new robot before its control loop starts, or refuse it at
+    # once; how long a queued robot waits before it is told why. {gs-plans/parallel/serving-queue.md "connect 的处理顺序"}
+    on_full: Literal["queue", "reject"] = "queue"
+    queue_timeout_s: int = Field(default=120, ge=5, le=3600)
 
 
 class Timeouts(BaseModel):
@@ -104,8 +125,9 @@ class InferParam(BaseModel):
 
 
 class DeploymentPolicy(BaseModel):
-    """The policy block of the deployments body. `handler_ref` and `action` are required; `action` is the
-    fixed obs→ActionChunk contract, not a bare dict.
+    """The policy block of the deployments body. Only `handler_ref` is required. The robot-arm preset's contracts
+    (`action`, `observation`, `embodiments`) are optional since contract 0.4.14: a deployment that declares none is held
+    to nothing and its inputs / outputs pass through the worker untouched.
 
     `secrets` carries the policy's declared secret BUNDLES BY NAME ONLY (list[SecretRef]) — the gateway
     validates each name exists and belongs to the deployer at submit time (accounts ⑦ / S3 goal 14), and the
@@ -116,7 +138,7 @@ class DeploymentPolicy(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
     handler_ref: str
-    action: ActionContract
+    action: ActionContract | None = None
     streaming: bool = False
     frames_per_chunk: int | None = None
     secrets: list[SecretRef] = Field(default_factory=list)
@@ -124,11 +146,14 @@ class DeploymentPolicy(BaseModel):
     # contracts for a multi-embodiment policy — the worker picks one by the session's embodiment.
     observation: ObservationContract | None = None
     embodiments: dict[str, Embodiment] | None = None
-    # Did the author declare `action=` (or embodiments)? `action` is required on the wire, so an SDK that had
-    # nothing declared sends a placeholder; only a declared contract is enforced on the worker and handed to the
-    # robot. None (an older SDK) is treated as undeclared, so an older policy is never refused for the
-    # placeholder it never chose. {io-contract.md "旧 SDK 写的 POLICY 照样能 BUILD"}
+    # Did the author declare `action=` (or embodiments)? SDKs before contract 0.4.14 always sent an `action` (a
+    # placeholder when none was declared); only a declared contract is enforced on the worker and handed to the robot.
+    # None (an older SDK) is treated as undeclared, so an older policy is never refused for the placeholder it never
+    # chose. A current SDK sends `action` only when declared. {io-contract.md "旧 SDK 写的 POLICY 照样能 BUILD"}
     action_declared: bool | None = None
+    # The author's own description of what infer() takes and returns; stored, handed to the robot at connect, never
+    # interpreted by the platform.
+    io: str | None = Field(default=None, max_length=4000)
     # The inference parameters @seq.infer takes beyond the observation (name -> type, default). None: an older
     # SDK that did not look; {}: the policy declares none.
     params: dict[str, InferParam] | None = Field(default=None, max_length=32)
@@ -149,7 +174,7 @@ request limit (base64 adds a third)."""
 
 class CodeBundle(BaseModel):
     """The policy's own source, shipped with the deploy so the worker can import `policy.handler_ref`
-    (what Modal's automount does for the entrypoint module). A gzip'd tar of the handler's top-level module
+    — the entrypoint module, mounted for it. A gzip'd tar of the handler's top-level module
     or package, base64 on the wire, with the sha256 of the decoded bytes so a truncated or altered upload
     is refused at the edge instead of failing as an ImportError on a GPU."""
 
@@ -201,11 +226,8 @@ class DeploymentRequest(BaseModel):
     # both key and value; the gateway only stores the dump, no consumer needs dict lookup.
     volumes: list[VolumeAttach] = Field(default_factory=list)
     autoscaler: Autoscaler = Field(default_factory=Autoscaler)
-    # An omitted @seq.concurrent must NOT send null: the gateway would then have no concurrency to scale by.
-    # Materialize the spec default — contracts.md §2's example {"max_inputs": 1, "target_inputs": 1}, i.e.
-    # one input per container (Modal's no-`@modal.concurrent` semantics) — same discipline as `autoscaler`
-    # (goal 13).
-    concurrency: Concurrency = Field(default_factory=lambda: Concurrency(max_inputs=1, target_inputs=1))
+    # Every field optional: an omitted @seq.concurrent serves one robot session per model copy, one copy per card.
+    concurrency: Concurrency = Field(default_factory=Concurrency)
     timeouts: Timeouts | None = None
     # Weights in several named parts: `weights` is the first and `weights_name` its name; `extra_weights` the others,
     # each provisioned like `weights`. @seq.load then receives {name: directory}. Both None (and absent from the wire):
@@ -279,3 +301,5 @@ class DeploymentStatusResponse(BaseModel):
     status: DeploymentState
     model: str
     error: str | None = Field(default=None, description="Build-failure reason; set only when FAILED")
+    # Why a deployment that was serving was marked FAILED: its workers kept dying of the same cause.
+    reason: Literal["gpu_out_of_memory", "host_out_of_memory", "crashed"] | None = None

{sequence_base-0.3.16 → sequence_base-0.3.18}/sequence_base/contract/eval.py

@@ -20,6 +20,10 @@ __all__ = [
     "Estimate",
     "EvalResponse",
     "EvalDryRunResponse",
+    "CardSide",
+    "CardInUse",
+    "EvalCards",
+    "EvalQueue",
     "RolloutResult",
     "EvalStatus",
     "SuiteAgg",
@@ -42,8 +46,15 @@ class EvalRequest(BaseModel):
     benchmark: str
     suite: str | None = None
     trials: int | None = None
-    gpus: int | None = None
-    envs_per_gpu: int | None = None
+    # How the eval is laid out, written by the user and never derived: how many policy machines and on which card
+    # (default: one, on the deployment's declared card), how many benchmark machines and on which card (default: one,
+    # on the benchmark's declared card), and how many environments each benchmark machine runs (default: the
+    # benchmark author's `envs=`, else 1). {gs-plans/parallel/eval.md "1. 两边写法对齐"}
+    policy_instances: int = Field(default=1, ge=1, le=64)
+    policy_gpu: str | None = Field(default=None, max_length=32)
+    benchmark_instances: int = Field(default=1, ge=1, le=64)
+    benchmark_gpu: str | None = Field(default=None, max_length=32)
+    envs: int | None = Field(default=None, ge=1, le=100000)
     vlm_max_concurrency: int | None = None
     adapter: str | None = None
     compare: str | None = Field(default=None, description="Another model id to compare against")
@@ -90,6 +101,56 @@ class EvalResponse(BaseModel):
     gpus_granted: int
     estimate: Estimate
     clamped_by: ClampInfo | None = None
+    # Set when the account was short of GPUs: the eval waits (up to its timeout) instead of being refused.
+    queue: EvalQueue | None = None
+
+
+class CardSide(BaseModel):
+    """One side of an eval's machines: how many, on which card, and how many GPUs each holds."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    instances: int
+    gpu: str
+    cards_each: int
+
+
+class CardInUse(BaseModel):
+    """The account's GPUs held now, serving and evals apart; None when it could not be read."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    serving: int | None = None
+    eval: int | None = None
+
+
+class EvalCards(BaseModel):
+    """The dry-run's card report — the same checks a real submit runs, without starting or charging anything.
+    {gs-plans/parallel/eval.md "4. 预演里卡的部分"}"""
+
+    model_config = ConfigDict(extra="forbid")
+
+    policy: CardSide
+    benchmark: CardSide
+    total: int
+    limit: int
+    in_use: CardInUse
+    available: int | None = None
+    short: int = 0
+    reason: Literal["gpu_limit_reached", "gpu_busy", "gpu_low_stock"] | None = None
+    would_queue: bool = False
+    queue_timeout_s: int = 600
+
+
+class EvalQueue(BaseModel):
+    """An eval waiting for the account's GPUs: what it needs, what is free, how long it has waited, when it gives up."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    cards: int
+    available: int | None = None
+    waited_s: float = 0
+    gives_up_at: str | None = None
 
 
 class EvalDryRunResponse(BaseModel):
@@ -98,6 +159,7 @@ class EvalDryRunResponse(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
     estimate: Estimate
+    cards: EvalCards | None = None
 
 
 class RolloutResult(BaseModel):
@@ -124,6 +186,7 @@ class EvalStatus(str, Enum):
     """Restricted enum — same discipline as DeploymentState (not a free string)."""
 
     PENDING = "pending"
+    QUEUED = "queued"
     RUNNING = "running"
     COMPLETED = "completed"
     FAILED = "failed"

{sequence_base-0.3.16 → sequence_base-0.3.18}/sequence_base/contract/flags.py

@@ -3,10 +3,8 @@
 reads back. One IntFlag, so a registration can carry several lifecycle entrypoints in one integer and
 the harness recovers each by testing a bit.
 
-Modeled on Modal's `_PartialFunctionFlags` (one IntFlag, one bit per lifecycle hook)
-{modal _partial_function.py:29}. Four members map bit-for-bit onto Modal's flags so the harness can be
-a thin adaptation of Modal's loader; the rest are platform-only lifecycle hooks Modal has no analogue
-for (a warm-up hook, a plan step, and the benchmark SETUP / RESET / CHECK / SCORE quartet).
+One bit per lifecycle hook: load, infer, an episode boundary and shutdown for a policy; a warm-up hook and a
+plan step; and the benchmark SETUP / RESET / CHECK / SCORE quartet.
 
 eval-raw revision: the platform provides the reset→step→check loop as a tool; the user defines the goal
 through four hooks — SETUP (load sim + assets), RESET (build one episode's env), CHECK (per-step: read raw
@@ -14,10 +12,10 @@ env state → done + user-named metrics), SCORE (cross-episode aggregate). RESET
 the new hook bits. The old single-hook `ROLLOUT` is DEPRECATED: bit 8192 stays reserved (never reused for
 another member) but appears in NO bindings — the setup/reset/check/score model replaces it.
 
-The exact bit values are the contract — see `MODAL_MAPPING` / `PLATFORM_ONLY` for the authoritative
-"member → bit value → Modal counterpart" list. A member taking the wrong value, WARMUP collapsing back
-into LOAD, RESET/CHECK overlapping an existing bit, or ROLLOUT being re-bound is caught bit-by-bit (see
-tests), not waved away with "an IntFlag is naturally bit-composable".
+The exact bit values are the contract: a registration serialized by one version must decode the same in
+another. A member taking the wrong value, WARMUP collapsing back into LOAD, RESET/CHECK overlapping an
+existing bit, or ROLLOUT being re-bound is caught bit-by-bit (see tests), not waved away with "an IntFlag
+is naturally bit-composable".
 """
 from __future__ import annotations
 
@@ -25,18 +23,18 @@ from enum import IntFlag
 
 
 class SeqFlags(IntFlag):
-    # ── mapped bit-for-bit onto Modal `_PartialFunctionFlags` ────────────────────────────────────
-    LOAD = 2            # Modal ENTER — load weights into VRAM (one-shot; no snapshot bisection)
-    SHUTDOWN = 8        # Modal EXIT — teardown / release the container
-    INFER = 16          # Modal CALLABLE_INTERFACE — the obs→ActionChunk call
-    ON_EPISODE = 1024   # Modal ~SESSIONED — sticky / session boundary for stateful policies
+    # ── a policy's lifecycle ────────────────────────────────────────────────────────────────────────
+    LOAD = 2            # load weights into VRAM (one-shot; no snapshot bisection)
+    SHUTDOWN = 8        # teardown / release the container
+    INFER = 16          # the obs→ActionChunk call
+    ON_EPISODE = 1024   # sticky / session boundary for stateful policies
 
-    # ── platform-only: no Modal counterpart; each an independent, disjoint bit ────────────────────
+    # ── each an independent bit, disjoint from the four above ──────────────────────────────────────
     # WARMUP is its OWN bit, NOT an alias of LOAD (S1.yaml goal 5 — "WARMUP=1(独立 bit,明确不并入
     # LOAD)"). A policy may bind @seq.load and @seq.warmup to two different methods → two independent
     # bindings, so the bit must be distinct from LOAD. Value 1 is bit 0, unused by any mapped flag.
-    WARMUP = 1          # JIT warm-up hook (ours; Modal folded warm-up into ENTER, we keep it separate)
-    PLAN = 4            # a policy planning step (ours; Modal has none) — bit 2, unused by Modal
+    WARMUP = 1          # JIT warm-up hook, kept separate from LOAD
+    PLAN = 4            # a policy planning step — bit 2
     # benchmark lifecycle (eval-raw: platform provides the loop tool, user hooks the goal in) — each an
     # independent, disjoint bit, disjoint too from every mapped bit:
     SETUP = 4096        # load sim + assets, once (≈ @seq.load)
@@ -49,21 +47,6 @@ class SeqFlags(IntFlag):
     ROLLOUT = 8192
 
 
-# Authoritative "member → Modal counterpart" list. Anything here must equal the bit above; anything in
-# PLATFORM_ONLY must be disjoint from every mapped bit and from each other.
-MODAL_MAPPING: dict[str, str] = {
-    "LOAD": "ENTER",
-    "SHUTDOWN": "EXIT",
-    "INFER": "CALLABLE_INTERFACE",
-    "ON_EPISODE": "~SESSIONED",
-}
-
-# Platform-only members Modal has no flag for. ROLLOUT is included: it is still a real (if deprecated)
-# member and its bit must stay disjoint from every other, so the disjointness check must cover it.
-PLATFORM_ONLY: frozenset[str] = frozenset(
-    {"WARMUP", "PLAN", "SETUP", "SCORE", "RESET", "CHECK", "ROLLOUT"}
-)
-
 # The benchmark lifecycle bits a live registration may bind (eval-raw): SETUP / RESET / CHECK / SCORE.
 # ROLLOUT is deliberately absent — deprecated, never bound.
 BENCHMARK_BINDABLE: frozenset[SeqFlags] = frozenset(

sequence_base-0.3.18/sequence_base/contract/io.py

@@ -0,0 +1,17 @@
+"""
+The robot-arm I/O contracts (`action=`, `observation=`, `embodiments=`), re-exported from
+`sequence_base.presets.robot_arm`.
+
+Declaring one is optional since contract 0.4.14: a deployment that declares none is held to nothing, and its
+`inputs` / `outputs` pass through the worker untouched. A declared contract is still enforced by the worker and
+handed to the robot at connect. {gs-plans/custom-io/README.md "2. worker:原样交给用户代码"}
+"""
+from sequence_base.presets.robot_arm import (  # noqa: F401 — re-exports
+    PROPRIO_FIELDS,
+    ActionContract,
+    Camera,
+    Embodiment,
+    ObservationContract,
+)
+
+__all__ = ["ActionContract", "PROPRIO_FIELDS", "Camera", "ObservationContract", "Embodiment"]