sequence-base 0.4.27__tar.gz → 0.4.29__tar.gz

{sequence_base-0.4.27 → sequence_base-0.4.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sequence-base
-Version: 0.4.27
+Version: 0.4.29
 Summary: Shared foundation for the Sequences platform — wire contract, correlation, error taxonomy, constants. Used by the robot SDK, gateway, and container harness.
 Project-URL: Changelog, https://generalsequences.com/docs/changelog/
 Requires-Python: >=3.10

{sequence_base-0.4.27 → sequence_base-0.4.29}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sequence-base"
-version = "0.4.27"
+version = "0.4.29"
 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.10"
 dependencies = ["pydantic>=2.0"]

{sequence_base-0.4.27 → sequence_base-0.4.29}/sequence_base/__init__.py

@@ -130,6 +130,9 @@ from sequence_base.errors.transport import (
 from sequence_base.episode import Episode
 
 
+from sequence_base.feedback import Feedback
+
+
 from sequence_base import auth
 
 
@@ -174,7 +177,7 @@ __all__ = [
 
     "TransportUnavailable", "TransportWarming", "TransportRejected", "TransportOverloaded",
 
-    "Episode",
+    "Episode", "Feedback",
 
     "auth",
 ]

{sequence_base-0.4.27 → sequence_base-0.4.29}/sequence_base/constants/version.py

@@ -4,7 +4,9 @@
 
 
 
-CONTRACT_VERSION = "0.5.24"
+CONTRACT_VERSION = "0.5.26"
+
+
 
 
 

{sequence_base-0.4.27 → sequence_base-0.4.29}/sequence_base/contract/connect.py

@@ -62,3 +62,6 @@ class ConnectResponse(BaseModel):
 
     observations: Observations | None = None
     actions: Actions | None = None
+
+
+    feedback: bool | None = None

{sequence_base-0.4.27 → sequence_base-0.4.29}/sequence_base/contract/deployments.py

@@ -184,6 +184,9 @@ class DeploymentPolicy(BaseModel):
 
 
     streaming: bool = Field(default=False, exclude=True)
+
+
+    feedback: bool | None = None
     secrets: list[SecretRef] = Field(default_factory=list)
 
 
@@ -216,12 +219,6 @@ class DeploymentPolicy(BaseModel):
 
 
 
-
-    own_observations: Literal["latest", "since_last_act"] | None = None
-    own_actions: Literal["one", "steps"] | None = None
-
-
-
     observations: Observations | None = None
     actions: Actions | None = None
     tensors: Tensors | None = None
@@ -239,9 +236,6 @@ class DeploymentPolicy(BaseModel):
 
     @model_validator(mode="after")
     def _own_io(self) -> "DeploymentPolicy":
-        if (self.own_observations or self.own_actions) and (self.action or self.observation or self.embodiments):
-            raise ValueError("own_observations and own_actions are for a policy of its own inputs and outputs; this one "
-                             "declares the robot-arm contract, where observation history and the action chunk say it")
         check_own_io(self)
         return self
 

sequence_base-0.4.29/sequence_base/contract/obs_schedule.py

@@ -0,0 +1,170 @@
+"""
+Which steps of an episode a policy of its own inputs is handed at an act, and which keys of each: its Observations
+(contract.own_io) read for one act - the one rule a worker hands a robot's streamed frames by
+, an eval hands its benchmark's by (obs_history), and a robot's SDK uploads by.
+
+In one sentence: an act at step t, the act before it at t_prev (-1: none yet) → each key's steps - its `at` offsets
+t + off (a window: the worker keeps the frames), every k steps of (t_prev, t] counting back from t (fed: the policy keeps
+them), else t alone; Observations(every=k) the whole observation so → a step before the episode's first reads as its
+first (pad "repeat_first") or goes ("drop") → oldest first, each with the keys read at it, the act's own last:
+{"observations": [...], "steps": [...]}. unit "seconds" counts seconds, taken to steps by the control rate of whoever
+steps the episode - the robot's, the benchmark's - which its caller passes.
+
+WHY one rule in one place: the worker, an eval and the SDK each act on the same declaration - which frames to keep,
+which to render, which to upload - and a step one of them reads differently is a frame a policy is handed that it never
+asked for, or never handed one it did. A robot's SDK restates it (it never imports sequence_base); its tests hold it to
+this.
+
+    sched = obs_schedule.of(observations, rate=10.0)        # None: nothing declared - the act's own, as always
+    obs_schedule.picks(sched, t=20, t_prev=12)              # [(5, ("cam",)), (20, ("cam", "state"))]
+    obs_schedule.envelope(picked, frames={5: {...}}, own={...}, t=20)
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+__all__ = ["Schedule", "envelope", "keeps_from", "needed", "of", "picks", "reads_past", "wanted"]
+
+Keys = tuple[str, ...] | None
+
+
+@dataclass(frozen=True)
+class Schedule:
+    """An Observations declaration in steps. `windows`: key -> its offsets (each 0 or below, oldest first); `fed`:
+    key -> every how many steps; `alone`: keys read at the act's step alone; `every`: the whole observation fed every
+    so many steps (no keys named); `whole`: no keys named - the whole observation; `pad`: "repeat_first" or "drop"."""
+
+    windows: dict
+    fed: dict
+    alone: tuple
+    every: int | None
+    whole: bool
+    pad: str
+
+
+def _get(d: Any, name: str) -> Any:
+    return d.get(name) if isinstance(d, dict) else getattr(d, name, None)
+
+
+def of(observations: Any, rate: float | None = None) -> Schedule | None:
+    """The schedule an Observations declaration - the model, or its JSON - reads by; None when there is none (the act's
+    own observation, as before). `rate`: the control steps a second of whoever steps the episode, for unit "seconds"
+    alone. Raises ValueError for unit "seconds" without it."""
+    if observations is None:
+        return None
+    unit = _get(observations, "unit") or "steps"
+
+    def steps(x: Any) -> int:
+        if unit != "seconds":
+            return int(x)
+        if not rate:
+            raise ValueError("this policy counts its observations in seconds (unit='seconds'): the control rate of the "
+                             "robot or benchmark stepping the episode takes them to steps, and none was given")
+        return int(round(float(x) * float(rate)))
+
+    windows, fed, alone = {}, {}, []
+    streams = _get(observations, "streams")
+    for key, stream in (streams or {}).items():
+        at, every = _get(stream, "at"), _get(stream, "every")
+        if at is not None:
+            windows[key] = tuple(sorted({min(0, steps(x)) for x in at}))
+        elif every is not None:
+            fed[key] = max(1, steps(every))
+        else:
+            alone.append(key)
+    every = _get(observations, "every")
+    return Schedule(windows=windows, fed=fed, alone=tuple(alone), every=max(1, steps(every)) if every is not None else
+                    None, whole=streams is None, pad=_get(observations, "pad") or "repeat_first")
+
+
+def reads_past(declared: Any) -> bool:
+    """Whether an act reads a step before its own - a window reaching back, a fed key, the whole observation fed -
+    whose frames must reach the worker before the act does (its observation stream, POST /observe). `declared`: a
+    Schedule, or the Observations declaration itself (the model or its JSON) - read with no control rate, which only
+    scales a count in seconds."""
+    if declared is None:
+        return False
+    if isinstance(declared, Schedule):
+        return (any(off < 0 for offsets in declared.windows.values() for off in offsets) or bool(declared.fed)
+                or (declared.whole and declared.every is not None))
+    if _get(declared, "every") is not None:
+        return True
+    for stream in (_get(declared, "streams") or {}).values():
+        if _get(stream, "every") is not None or any(x < 0 for x in _get(stream, "at") or ()):
+            return True
+    return False
+
+
+def picks(sched: Schedule | None, t: int, t_prev: int = -1) -> list[tuple[int, Keys]]:
+    """(step, keys) of each observation the act at step `t` is handed, oldest first, the act's own last - keys None for
+    the whole observation. A step before the episode's first is its first (step 0) under pad "repeat_first", once for
+    each such step asked, and is left out under "drop". `t_prev`: the act before it (-1: the episode's first)."""
+    if sched is None:
+        return [(t, None)]
+    asked: dict[int, set] = {}
+    whole: set[int] = set()
+    for key, offsets in sched.windows.items():
+        for off in offsets:
+            asked.setdefault(t + off, set()).add(key)
+    for key, k in sched.fed.items():
+        for s in range(t, t_prev, -k):
+            asked.setdefault(s, set()).add(key)
+    for key in sched.alone:
+        asked.setdefault(t, set()).add(key)
+    if sched.whole:
+        whole.update(range(t, t_prev, -sched.every) if sched.every else (t,))
+    out: list[tuple[int, Keys]] = []
+    for s in sorted(set(asked) | whole):
+        if s < 0 and sched.pad == "drop":
+            continue
+        out.append((max(0, s), None if s in whole else tuple(sorted(asked[s]))))
+    return out
+
+
+def needed(sched: Schedule | None, t: int, t_prev: int = -1) -> set[int]:
+    """The steps the act at `t` reads but does not carry itself: their frames come before it (the stream)."""
+    return {s for s, _ in picks(sched, t, t_prev) if s != t}
+
+
+def keeps_from(sched: Schedule | None, t: int) -> int:
+    """The earliest step an act after the one at `t` may read: a window reaches back its furthest offset from an act
+    one step on at the soonest; a fed key, the whole observation and a key read alone, nothing at or before `t`."""
+    reach = min((offsets[0] for offsets in (sched.windows.values() if sched else ())), default=0)
+    return max(0, t + 1 + min(0, reach))
+
+
+def _merge(into: dict, step: int, keys: Keys) -> None:
+    if keys is None or into.get(step, ()) is None:
+        into[step] = None
+    else:
+        into[step] = tuple(sorted({*into.get(step, ()), *keys}))
+
+
+def wanted(sched: Schedule | None, t: int, t_next: int) -> dict[int, Keys]:
+    """{step: keys} to read - an eval's benchmark - or upload - a robot's SDK - among the steps after the act at `t` and
+    before the next at `t_next` (t_next itself is that act's own, carried by it): those the act at t_next reads, and
+    those a later act may - an act after t_next reads a window key at any step from t_next + 1 + its furthest offset,
+    which a window longer than one act's turn reaches back into."""
+    out: dict[int, Keys] = {}
+    for s, keys in picks(sched, t_next, t):
+        if t < s < t_next:
+            _merge(out, s, keys)
+    for key, offsets in (sched.windows.items() if sched else ()):
+        for s in range(max(t + 1, t_next + 1 + offsets[0]), t_next):
+            _merge(out, s, (key,))
+    return dict(sorted(out.items()))
+
+
+def envelope(picked: list[tuple[int, Keys]], frames: dict, own: Any, t: int) -> dict:
+    """{"observations": [...], "steps": [...]}: each picked observation - `own`, the act's, at `t`, else `frames[step]`
+    - with only the keys read at it (a key it lacks is left out), oldest first. Raises KeyError for a step not in
+    `frames`."""
+    observations, steps = [], []
+    for step, keys in picked:
+        obs = own if step == t else frames[step]
+        if keys is not None and isinstance(obs, dict):
+            obs = {k: obs[k] for k in keys if k in obs}
+        observations.append(obs)
+        steps.append(step)
+    return {"observations": observations, "steps": steps}

{sequence_base-0.4.27 → sequence_base-0.4.29}/sequence_base/contract/observe.py

@@ -14,7 +14,8 @@ are on the worker before the act is.
 
 What a policy declares of what it reads (its cameras, how many a second, when its upload falls behind) is plan 87's
 first layer, which waits for the comparison of each part (the user's 69): the stream here is the transport alone, for
-a policy that declares own_observations "since_last_act".
+a policy fed every observation since its last act (Observations(every=1); own_observations "since_last_act" until
+contract 0.5.25).
 
 """
 from __future__ import annotations

{sequence_base-0.4.27 → sequence_base-0.4.29}/sequence_base/contract/own_io.py

@@ -20,13 +20,15 @@ breaks a policy is a frame fitted or encoded other than it was trained on, which
 from __future__ import annotations
 
 import math
+import numbers
+from collections.abc import Mapping
 from typing import Any, Literal
 
 from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
 
 from sequence_base.presets.robot_arm import Camera
 
-__all__ = ["Actions", "MAX_STREAMS", "MAX_WINDOW", "Observations", "Stream", "Tensors", "check_own_io"]
+__all__ = ["Actions", "MAX_STREAMS", "MAX_WINDOW", "Observations", "Stream", "Tensors", "check_own_io", "rows_of"]
 
 
 
@@ -103,6 +105,15 @@ class Observations(BaseModel):
     streams: dict[str, Stream] | None = Field(default=None, max_length=MAX_STREAMS)
     every: int | float | None = Field(default=None, gt=0)
     unit: Literal["steps", "seconds"] = "steps"
+
+    def __init__(self, streams: dict[str, Stream] | None = None, /, **data: Any) -> None:
+
+
+        if streams is not None:
+            if "streams" in data:
+                raise TypeError("Observations takes the keys it reads once: first, or as streams=")
+            data["streams"] = streams
+        super().__init__(**data)
     pad: Literal["repeat_first", "drop"] = "repeat_first"
     when_behind: Literal["wait", "drop_oldest"] = "wait"
 
@@ -152,6 +163,9 @@ class Actions(BaseModel):
     open_loop_horizon: int | None = Field(default=None, ge=1, le=100_000)
 
 
+    aligned: bool | None = None
+
+
 class Tensors(BaseModel):
     """A policy's inputs reach its code as torch tensors on its device - a batch dimension first when `batch` - and the
     tensors it answers with go back as arrays; float64 arrays arrive as float32. Converted in the replica, last before
@@ -162,10 +176,62 @@ class Tensors(BaseModel):
     batch: bool = True
 
 
+def rows_of(answer: Any, actions: Any = None) -> list:
+    """The rows of a policy's own answer that play, in order - one rule for an eval and a robot. `actions`: its Actions,
+    the model or its JSON; declared, each element of the field its `key` names (the answer itself for none) is a row,
+    a dict one too, cut at its `open_loop_horizon`. Undeclared, the default: a dict, or a list of numbers, is one action;
+    a list of lists of one length, or a 2-D array, plays row by row; a ragged or deeper nesting, or a list of dicts, is
+    refused, saying to declare actions= - and a number, a text or any other object is one action, as before.
+    
+"""
+    if actions is not None:
+        key = actions.get("key") if isinstance(actions, dict) else actions.key
+        horizon = actions.get("open_loop_horizon") if isinstance(actions, dict) else actions.open_loop_horizon
+        where = "answer" if key is None else f"answer's {key!r} field"
+        if key is not None:
+            if not isinstance(answer, Mapping) or key not in answer:
+                raise ValueError(f"the policy's answer has no {key!r} field, which its actions=seq.Actions(key={key!r}) "
+                                 "names as the rows to play")
+            answer = answer[key]
+        if isinstance(answer, (Mapping, str, bytes)) or not (isinstance(answer, (list, tuple))
+                                                             or (getattr(answer, "ndim", 0) or 0) >= 1):
+            raise ValueError(f"the policy's {where} is {type(answer).__name__}, not a list of rows or an array of them")
+        rows = list(answer)
+        if not rows:
+            raise ValueError(f"the policy's {where} holds no rows to play")
+        return rows[:horizon] if horizon else rows
+    ndim = getattr(answer, "ndim", None)
+    if isinstance(ndim, int) and not isinstance(answer, (Mapping, str, bytes)):
+        if ndim <= 1:
+            return [answer]
+        if ndim == 2:
+            return list(answer)
+        raise ValueError(_unplayable(f"an array of {ndim} dimensions"))
+    if isinstance(answer, (list, tuple)):
+        if all(isinstance(v, numbers.Number) for v in answer):
+            return [answer]
+        if all(isinstance(v, (list, tuple)) or getattr(v, "ndim", None) == 1 for v in answer):
+            lengths = [len(v) for v in answer]
+            if len(set(lengths)) == 1:
+                return list(answer)
+            raise ValueError(_unplayable(f"a list of lists of lengths {', '.join(map(str, lengths))}"))
+        if all(isinstance(v, Mapping) for v in answer):
+            raise ValueError(_unplayable(f"a list of {len(answer)} dicts"))
+        kinds = dict.fromkeys("numbers" if isinstance(v, numbers.Number) else "lists" if isinstance(v, (list, tuple))
+                              else type(v).__name__ for v in answer)
+        raise ValueError(_unplayable(f"a list of {' and '.join(kinds)}"))
+    return [answer]
+
+
+def _unplayable(what: str) -> str:
+    return (f"the policy's answer is {what}, which plays neither as one action (a dict, or a list of numbers) nor row by "
+            "row (a list of lists of one length, or a 2-D array): declare actions=seq.Actions() for its rows to play in "
+            "order, or turn it into actions yourself (actions_of= on a robot, an adapter in an eval)")
+
+
 def check_own_io(spec: Any) -> None:
     """What PolicySpec and DeploymentPolicy both hold a policy's own-I/O declarations to: none beside the robot-arm
-    contract, which says what it reads and plays its own way, and the 0.5.24 ones (observations / actions / tensors)
-    not beside own_observations / own_actions, which they take over from."""
+    contract, which says what it reads and plays its own way."""
     new = [name for name in ("observations", "actions", "tensors") if getattr(spec, name) is not None]
     if not new:
         return
@@ -173,7 +239,3 @@ def check_own_io(spec: Any) -> None:
         raise ValueError(f"{', '.join(new)} {'is' if len(new) == 1 else 'are'} for a policy of its own inputs and "
                          "outputs; this one declares the robot-arm contract, where observation history and the action "
                          "chunk say it")
-    old = [name for name in ("own_observations", "own_actions") if getattr(spec, name)]
-    if old:
-        raise ValueError(f"{', '.join(new)} and {', '.join(old)} say what a policy reads and plays two ways; declare "
-                         "observations= and actions= alone")

{sequence_base-0.4.27 → sequence_base-0.4.29}/sequence_base/contract/policy.py

@@ -377,6 +377,10 @@ class PolicySpec(BaseModel):
 
     streaming: bool = Field(default=False, exclude=True)
 
+
+
+    feedback: bool | None = None
+
     action: ActionContract | None = None
 
     observation: ObservationContract | None = None
@@ -396,12 +400,6 @@ class PolicySpec(BaseModel):
 
 
 
-    own_observations: Literal["latest", "since_last_act"] | None = None
-    own_actions: Literal["one", "steps"] | None = None
-
-
-
-
     observations: Observations | None = None
     actions: Actions | None = None
     tensors: Tensors | None = None
@@ -433,9 +431,6 @@ class PolicySpec(BaseModel):
 
     @model_validator(mode="after")
     def _own_io(self) -> "PolicySpec":
-        if (self.own_observations or self.own_actions) and (self.action or self.observation or self.embodiments):
-            raise ValueError("own_observations and own_actions are for a policy of its own inputs and outputs; this one "
-                             "declares the robot-arm contract, where observation history and the action chunk say it")
         check_own_io(self)
         return self
 

{sequence_base-0.4.27 → sequence_base-0.4.29}/sequence_base/contract/wire.py

@@ -46,6 +46,11 @@ class ActRequest(BaseModel):
                             description="The newest observation's number in its episode's stream (POST /observe)")
 
 
+
+    feedback: dict[str, Any] | None = Field(default=None,
+                                            description="What the robot was playing: left, delay, played, last")
+
+
 class ActResponse(BaseModel):
     """200 from /act, version 2. `outputs` is infer()'s return value, unchanged; the rest is platform metadata."""
 

sequence_base-0.4.29/sequence_base/feedback.py

@@ -0,0 +1,106 @@
+"""
+What a policy that asks for execution feedback is handed (PolicySpec.feedback): its infer declares `feedback` and gets,
+with each act, what the robot was playing when it sent that act - the rows it had not played yet, how many control
+steps it expects to play before the answer is back, how many rows of its chunk it had played, and the row it played
+last.
+
+In one sentence: the robot's executor (sequence_ai.Player, or an eval's) → puts {left, delay, played, last} in the act
+it sends → the worker checks it by feedback_of and hands infer a Feedback → a policy that inpaints (RTC) freezes the rows
+the delay covers, one trained on its last action reads `last`.
+
+WHY the executor fills it, act by act, and the platform keeps none of it: which rows are left and how long a round
+trip takes only the robot knows - a worker times the inference alone.
+
+"""
+from __future__ import annotations
+
+import numbers
+from collections.abc import Mapping
+from typing import Any
+
+__all__ = ["Feedback", "feedback_of", "KEYS"]
+
+
+KEYS = ("left", "delay", "played", "last")
+
+
+class Feedback:
+    """What the robot was playing when it sent this act: `left` - the rows of the chunk it was playing that it had not
+    played yet, in order, the ones due first and then the chunk's spare ones (empty on an episode's first act, or when
+    it held none); `delay` - how many control steps it expects to play before this answer is back, its longest of its
+    last 10 round trips times its control rate, rounded up (0 before it measured one, and in an eval); `played` - how
+    many rows of that chunk it had played when it observed; `last` - the row it played last, as the platform clipped it
+    (None before it played one). All four are the robot's: they are read, never set."""
+
+    __slots__ = ("_left", "_delay", "_played", "_last")
+
+    def __init__(self, left: Any = (), delay: int = 0, played: int = 0, last: Any = None) -> None:
+        object.__setattr__(self, "_left", tuple(left))
+        object.__setattr__(self, "_delay", int(delay))
+        object.__setattr__(self, "_played", int(played))
+        object.__setattr__(self, "_last", last)
+
+    @property
+    def left(self) -> tuple:
+        return self._left
+
+    @property
+    def delay(self) -> int:
+        return self._delay
+
+    @property
+    def played(self) -> int:
+        return self._played
+
+    @property
+    def last(self) -> Any:
+        return self._last
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        raise AttributeError(f"Feedback.{name} is what the robot was playing: read it, never set it")
+
+    def __repr__(self) -> str:
+        return (f"Feedback(left={len(self._left)} rows, delay={self._delay}, played={self._played}, "
+                f"last={self._last!r})")
+
+
+def feedback_of(value: Any, width: int | None = None) -> Feedback:
+    """The Feedback an act's `feedback` says - a dict of `left` (a list of rows, or an array of them), `delay` and
+    `played` (counts from 0) and `last` (a row, or None) - checked, the one rule a worker and a robot's SDK read it by:
+    with `width` (the robot-arm preset's action_dim) each row is that many numbers; without, a row of a policy's own
+    outputs is handed as it came. Raises ValueError saying what is wrong."""
+    if not isinstance(value, Mapping):
+        raise ValueError(f"feedback is a dict of {', '.join(KEYS)}, not {type(value).__name__}")
+    unknown = [k for k in value if k not in KEYS]
+    if unknown:
+        raise ValueError(f"feedback has no {', '.join(map(repr, unknown))}: it holds {', '.join(KEYS)}")
+    left = value.get("left")
+    if left is None:
+        left = ()
+    elif isinstance(left, (str, bytes, Mapping)) or not (isinstance(left, (list, tuple))
+                                                        or (getattr(left, "ndim", 0) or 0) >= 1):
+        raise ValueError(f"feedback's left is the rows the robot had not played, a list of them, not "
+                         f"{type(left).__name__}")
+    rows = list(left)
+    counts = {}
+    for key in ("delay", "played"):
+        n = value.get(key, 0)
+        if isinstance(n, bool) or not isinstance(n, numbers.Integral) or n < 0:
+            raise ValueError(f"feedback's {key} is a count of control steps from 0, not {n!r}")
+        counts[key] = int(n)
+    last = value.get("last")
+    if width is not None:
+        for where, row in [*((f"left[{i}]", r) for i, r in enumerate(rows)),
+                           *((("last", last),) if last is not None else ())]:
+            _fits(where, row, width)
+    return Feedback(rows, counts["delay"], counts["played"], last)
+
+
+def _fits(where: str, row: Any, width: int) -> None:
+    if isinstance(row, (str, bytes, Mapping)) or not (isinstance(row, (list, tuple)) or getattr(row, "ndim", None) == 1):
+        raise ValueError(f"feedback's {where} is a row of {width} numbers (the policy's action_dim), not "
+                         f"{type(row).__name__}")
+    if len(row) != width:
+        raise ValueError(f"feedback's {where} has {len(row)} values; the policy's action_dim is {width}")
+    if not all(isinstance(v, numbers.Real) and not isinstance(v, bool) for v in row):
+        raise ValueError(f"feedback's {where} is a row of {width} numbers (the policy's action_dim)")

{sequence_base-0.4.27 → sequence_base-0.4.29}/sequence_base/presets/robot_arm.py

@@ -129,6 +129,10 @@ class ActionContract(BaseModel):
     bounds: list[tuple[float, float]] | None = Field(default=None, max_length=256)
     max_delta: float | list[float] | None = None
 
+
+
+    aligned: bool | None = None
+
     @model_validator(mode="after")
     def _limits_fit(self) -> "ActionContract":
         if self.bounds is not None:

{sequence_base-0.4.27 → sequence_base-0.4.29}/sequence_base/schemas/ActRequest.json

@@ -28,6 +28,20 @@
       "description": "The episode this call belongs to (per-episode state)",
       "title": "Episode Id"
     },
+    "feedback": {
+      "anyOf": [
+        {
+          "additionalProperties": true,
+          "type": "object"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": null,
+      "description": "What the robot was playing: left, delay, played, last",
+      "title": "Feedback"
+    },
     "inputs": {
       "description": "Whatever the policy's infer() takes, exactly as the robot's code built it",
       "title": "Inputs"
@@ -93,5 +107,5 @@
   ],
   "title": "ActRequest",
   "type": "object",
-  "x-contract-version": "0.5.24"
+  "x-contract-version": "0.5.26"
 }

{sequence_base-0.4.27 → sequence_base-0.4.29}/sequence_base/schemas/ActResponse.json

@@ -89,5 +89,5 @@
   ],
   "title": "ActResponse",
   "type": "object",
-  "x-contract-version": "0.5.24"
+  "x-contract-version": "0.5.26"
 }

{sequence_base-0.4.27 → sequence_base-0.4.29}/sequence_base/schemas/ActionChunk.json

@@ -99,5 +99,5 @@
   ],
   "title": "ActionChunk",
   "type": "object",
-  "x-contract-version": "0.5.24"
+  "x-contract-version": "0.5.26"
 }

{sequence_base-0.4.27 → sequence_base-0.4.29}/sequence_base/schemas/ActionContract.json

@@ -23,6 +23,18 @@
     "action_space": {
       "$ref": "#/$defs/ActionSpace"
     },
+    "aligned": {
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": null,
+      "title": "Aligned"
+    },
     "bounds": {
       "anyOf": [
         {
@@ -84,5 +96,5 @@
   ],
   "title": "ActionContract",
   "type": "object",
-  "x-contract-version": "0.5.24"
+  "x-contract-version": "0.5.26"
 }

{sequence_base-0.4.27 → sequence_base-0.4.29}/sequence_base/schemas/ActionStep.json

@@ -19,5 +19,5 @@
   ],
   "title": "ActionStep",
   "type": "object",
-  "x-contract-version": "0.5.24"
+  "x-contract-version": "0.5.26"
 }

{sequence_base-0.4.27 → sequence_base-0.4.29}/sequence_base/schemas/Actions.json

@@ -2,6 +2,18 @@
   "additionalProperties": false,
   "description": "Which rows of a policy's answer play. `key`: the answer's field that holds them (None: the answer itself) - a\nlist of rows or a 2-D array, played in order, `hz` rows a second, `open_loop_horizon` of them before the next act\n(None: all). A shorter answer plays whole and the next act comes sooner; a longer one is cut there. With `hz` a worker\nknows how long one answer plays (open_loop_horizon / hz) and a control period (1 / hz) and times a copy's robots by\nthem, as a robot-arm chunk's covers_seconds and control_frequency_hz do. Undeclared, an answer plays as the default\nsays: a dict or a 1-D list one action, a 2-D one row by row.",
   "properties": {
+    "aligned": {
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": null,
+      "title": "Aligned"
+    },
     "hz": {
       "anyOf": [
         {
@@ -47,5 +59,5 @@
   },
   "title": "Actions",
   "type": "object",
-  "x-contract-version": "0.5.24"
+  "x-contract-version": "0.5.26"
 }