sequence-base 0.5.1__tar.gz → 0.6.0__tar.gz

{sequence_base-0.5.1 → sequence_base-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sequence-base
-Version: 0.5.1
+Version: 0.6.0
 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.5.1 → sequence_base-0.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sequence-base"
-version = "0.5.1"
+version = "0.6.0"
 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.5.1 → sequence_base-0.6.0}/sequence_base/__init__.py

@@ -86,8 +86,6 @@ from sequence_base.contract import (
     PolicyConstructor,
     PolicyRegistration,
     PolicySpec,
-    Observations,
-    Stream,
     Tensors,
     Proprioception,
     ReplaySpec,
@@ -145,7 +143,7 @@ __all__ = [
     "FROZEN_PATH", "TemplateFiles", "ImageStepTemplateFiles", "Project", "ImageStepProject", "ImageStep", "ImageSpec",
     "VolumeMount", "VolumeRef", "Concurrency", "ActionContract", "Camera", "ObservationContract",
     "PolicySpec", "PolicyRegistration", "PolicyConstructor",
-    "Observations", "Stream", "Tensors",
+    "Tensors",
 
     "MAX_CODE_BUNDLE_BYTES", "CodeBundle",
     "Resources", "Autoscaler", "Timeouts", "DeploymentPolicy", "InferParam", "DeploymentRequest",

sequence_base-0.6.0/sequence_base/codec/compressed.py

@@ -0,0 +1,174 @@
+"""
+Compressed observe items: what a robot's SDK puts in place of a large array or bytes of its observe data when sending it
+compressed saves more upload time than compressing it costs, and what a worker turns back - losslessly, so every reader
+after the worker is handed the bytes the robot built.
+
+
+
+In one sentence: the robot's SDK compresses an unmarked numpy array or bytes of 16 KiB or more with zstd level 1 (zlib
+level 1 where it has no zstd) and puts the map below in its place → the worker names contract.observe.ZSTD_FORMAT, so
+only it is sent such maps → as a post comes, before anything keeps it, expand() turns every map back into the array or
+bytes it was (np.frombuffer: read-only, as msgpack_io reads an array) and says how many bytes that added.
+
+The map, version 1 (inside the observe body's msgpack; `data` is bin):
+  {"__seq__": "compressed", "v": 1, "codec": "zstd" | "zlib", "n": <bytes before>, "data": <compressed>}
+      bytes as they were
+  ... and "type": numpy's string for its dtype, "shape": the array's - an array, its data C-ordered
+`n` is checked against the bytes the data turns back into, and against the most one item may hold (the bytes of an
+episode's observations a worker keeps): a map that says less than it holds is refused rather than decompressed past it.
+
+WHY the observation format's reserved key: marked items (codec/marked.py) already take a map with "__seq__", so one key
+is reserved in observe data, not two; a compressed item is never inside a marked one - the SDK compresses after encoding
+its markers and leaves their maps as they are - and expand() does not look inside one.
+WHY decompressed as the post comes, at the parent: the stream, Field data and the standby's saves all read a post's
+frames as it comes, and each must keep the robot's data, not the wire's.
+
+    wire = compress(frame, "zstd")                       # a reference encoder (the SDK has its own, with its rule)
+    value, grew = expand(post_inputs, limit=64 << 20)    # the worker, as a post comes
+"""
+from __future__ import annotations
+
+import zlib
+from typing import Any
+
+from sequence_base.codec.marked import MARK, is_marked
+
+__all__ = ["CODECS", "KIND", "VERSION", "CompressedError", "compress", "expand", "holds", "is_compressed"]
+
+KIND = "compressed"
+VERSION = 1
+CODECS = ("zstd", "zlib")
+_LEVEL = 1
+
+
+class CompressedError(ValueError):
+    """A compressed item that does not read: an unknown codec, data that does not turn back into the `n` bytes it says,
+    an `n` past the limit, or an array's type or shape that does not fit them."""
+
+
+def is_compressed(value: Any) -> bool:
+    return isinstance(value, dict) and value.get(MARK) == KIND
+
+
+def _zstd():
+    """zstd's (compress, decompress) - zstandard's, else Python 3.14's compression.zstd. The decompress takes the bytes
+    the item says it holds and refuses a frame whose header says other: a header is what sizes the buffer."""
+    try:
+        import zstandard
+
+        def unzstd(b: bytes, n: int) -> bytes:
+            said = zstandard.frame_content_size(b)
+            if said not in (-1, n):
+                raise CompressedError(f"a zstd item whose frame says {said} bytes and whose map says {n}")
+            return zstandard.ZstdDecompressor().decompress(b, max_output_size=n)
+
+        return (lambda b: zstandard.ZstdCompressor(level=_LEVEL).compress(b), unzstd)
+    except ImportError:
+        from compression import zstd
+
+        def unzstd(b: bytes, n: int) -> bytes:
+            said = zstd.get_frame_info(b).decompressed_size
+            if said not in (None, n):
+                raise CompressedError(f"a zstd item whose frame says {said} bytes and whose map says {n}")
+            d = zstd.ZstdDecompressor()
+            raw = d.decompress(b, max_length=n)
+            if not d.eof:
+                raise CompressedError(f"a zstd item that holds more than the {n} bytes it says")
+            return raw
+
+        return (lambda b: zstd.compress(b, level=_LEVEL), unzstd)
+
+
+def compress(value: Any, codec: str = "zstd") -> dict:
+    """`value` - a numpy array or bytes - as its compressed item: a reference encoder, for tests and the platform's own
+    senders; the robot's SDK decides by its own rule what to compress."""
+    import numpy as np
+
+    if isinstance(value, np.ndarray):
+        raw = np.ascontiguousarray(value).tobytes()
+        extra = {"type": value.dtype.str, "shape": list(value.shape)}
+    else:
+        raw, extra = bytes(value), {}
+    if codec == "zstd":
+        data = _zstd()[0](raw)
+    elif codec == "zlib":
+        data = zlib.compress(raw, _LEVEL)
+    else:
+        raise CompressedError(f"no codec {codec!r}: {', '.join(CODECS)}")
+    return dict([(MARK, KIND), ("v", VERSION), ("codec", codec), ("n", len(raw)), *extra.items(), ("data", data)])
+
+
+def _raw(item: dict, limit: int) -> bytes:
+    codec, n, data = item.get("codec"), item.get("n"), item.get("data")
+    if codec not in CODECS:
+        raise CompressedError(f"a compressed item of codec {codec!r}: {', '.join(CODECS)} are read")
+    if isinstance(n, bool) or not isinstance(n, int) or not 0 <= n <= limit:
+        raise CompressedError(f"a compressed item of {n!r} bytes: at most {limit} are taken")
+    if not isinstance(data, (bytes, bytearray)):
+        raise CompressedError("a compressed item whose data is not bytes")
+    try:
+        if codec == "zstd":
+            raw = _zstd()[1](bytes(data), n)
+        else:
+            d = zlib.decompressobj()
+            raw = d.decompress(bytes(data), n)
+            if d.unconsumed_tail or not d.eof:
+                raise CompressedError(f"a zlib item that holds more than the {n} bytes it says")
+    except CompressedError:
+        raise
+    except Exception as exc:
+        raise CompressedError(f"a {codec} item that does not read: {exc}") from None
+    if len(raw) != n:
+        raise CompressedError(f"a {codec} item of {len(raw)} bytes that says it holds {n}")
+    return raw
+
+
+def _value(item: dict, limit: int) -> Any:
+    raw = _raw(item, limit)
+    if "type" not in item and "shape" not in item:
+        return raw
+    import numpy as np
+
+    from sequence_base.msgpack_io import MsgpackError, _dtype
+
+    shape = item.get("shape")
+    if not isinstance(shape, list) or not all(isinstance(d, int) and not isinstance(d, bool) and d >= 0 for d in shape):
+        raise CompressedError("a compressed array whose shape is not a list of non-negative ints")
+    try:
+        dtype = _dtype(item.get("type"))
+    except MsgpackError as exc:
+        raise CompressedError(f"a compressed array: {exc}") from None
+    if dtype.itemsize * int(np.prod(shape, dtype=np.int64)) != len(raw):
+        raise CompressedError(f"a compressed {dtype} array of shape {shape} that holds {len(raw)} bytes")
+    return np.frombuffer(raw, dtype=dtype).reshape(shape)
+
+
+def expand(value: Any, *, limit: int) -> "tuple[Any, int]":
+    """`value` with every compressed item in it - in dicts and lists at any depth, never inside a marked item - turned
+    back into the array or bytes it was, the same objects where none is; and how many bytes that added. `limit`: the
+    most bytes one item may turn back into. CompressedError for an item that does not read."""
+    grew = [0]
+
+    def walk(v: Any) -> Any:
+        if isinstance(v, dict):
+            if is_compressed(v):
+                out = _value(v, limit)
+                grew[0] += max(0, int(v["n"]) - len(v["data"]))
+                return out
+            if is_marked(v) or not holds(v):
+                return v
+            return {k: walk(x) for k, x in v.items()}
+        if isinstance(v, list):
+            return [walk(x) for x in v] if holds(v) else v
+        return v
+
+    return walk(value), grew[0]
+
+
+def holds(value: Any) -> bool:
+    """Whether `value` holds a compressed item - in dicts and lists at any depth, not inside a marked item."""
+    if isinstance(value, dict):
+        return is_compressed(value) or (not is_marked(value) and any(holds(v) for v in value.values()))
+    if isinstance(value, list):
+        return any(holds(v) for v in value)
+    return False

{sequence_base-0.5.1 → sequence_base-0.6.0}/sequence_base/constants/limits.py

@@ -36,4 +36,4 @@ METRIC_UNIT_MAX = 16
 MAX_STREAM_FRAMES = 1024
 MAX_STREAM_BYTES = 64 * 1024 * 1024
 MAX_WORKER_STREAM_BYTES = 1024 * 1024 * 1024
-STREAM_WAIT_S = 10.0
+STREAM_WAIT_S = 3.0

{sequence_base-0.5.1 → sequence_base-0.6.0}/sequence_base/constants/version.py

@@ -4,7 +4,8 @@
 
 
 
-CONTRACT_VERSION = "0.5.33"
+CONTRACT_VERSION = "0.5.34"
+
 
 
 

{sequence_base-0.5.1 → sequence_base-0.6.0}/sequence_base/construct.py

@@ -1,5 +1,5 @@
 """
-How a class built by its constructor is built - a policy's or a team's (PolicyRegistration.constructor), a benchmark's
+How a class built by its constructor is built - a policy's or a planner's (PolicyRegistration.constructor), a benchmark's
 (BenchmarkSpec.constructor): its constructor - or the factory it names, a classmethod of it or a module's function -
 called with the arguments its decorator was given (init=), once the forms in them are filled in.
 

{sequence_base-0.5.1 → sequence_base-0.6.0}/sequence_base/contract/__init__.py

@@ -45,7 +45,7 @@ from sequence_base.contract.policy import (
 )
 
 
-from sequence_base.contract.own_io import Observations, Stream, Tensors
+from sequence_base.contract.own_io import OBSERVATIONS_GONE, Tensors
 
 
 from sequence_base.contract.deployments import (
@@ -124,20 +124,30 @@ from sequence_base.contract.settings import (
 )
 
 
-from sequence_base.contract.team import (
-    TEAM_DEFAULT_GROUP,
-    GroupObservation,
-    GroupObserve,
-    GroupObserved,
+
+from sequence_base.contract.planner import (
+    KEPT,
+    MOST_LAYERS,
+    PLANS_MOST,
+    STATE_MOST,
+    PLAN_ON_A_POLICY,
+    PLANNER_ID,
+    POLICY_ID,
+    ROBOT_ID,
+    TEAM_GONE,
     PlanAppend,
     PlanAppended,
-    TeamGroup,
-    TeamGroups,
-    TeamGroupsRequest,
-    TeamMember,
-    TeamPlans,
-    TeamPlansWritten,
-    TeamSpec,
+    PlannerMember,
+    PlannerObservation,
+    PlannerObserve,
+    PlannerObserved,
+    PlannerPlanIn,
+    PlannerPlans,
+    PlannerPlansWritten,
+    PlannerRobot,
+    PlannerRound,
+    PlannerRoundRequest,
+    PlannerSpec,
 )
 
 
@@ -154,7 +164,7 @@ __all__ = [
     "TemplateFiles", "ImageStepTemplateFiles", "Project", "ImageStepProject", "FROZEN_PATH", "ImageStep", "ImageSpec",
     "VolumeMount", "VolumeRef", "Concurrency", "ActionContract", "Camera", "ObservationContract",
     "PolicySpec", "PolicyRegistration", "PolicyConstructor",
-    "Observations", "Stream", "Tensors",
+    "OBSERVATIONS_GONE", "Tensors",
 
     "MAX_CODE_BUNDLE_BYTES", "CodeBundle",
     "Resources", "Autoscaler", "Timeouts", "DeploymentPolicy", "InferParam", "DeploymentRequest",
@@ -174,8 +184,9 @@ __all__ = [
     "SETTINGS", "Setting", "SettingsChange", "Applied", "SettingState", "SettingsView", "SettingChanged",
     "SettingsChanged",
 
-    "TEAM_DEFAULT_GROUP", "TeamSpec", "TeamGroupsRequest", "GroupObservation", "TeamMember", "TeamGroup", "TeamGroups",
-    "TeamPlans", "TeamPlansWritten", "PlanAppend", "PlanAppended", "GroupObserve", "GroupObserved",
+    "KEPT", "MOST_LAYERS", "PLANS_MOST", "STATE_MOST", "PLAN_ON_A_POLICY", "PLANNER_ID", "POLICY_ID", "ROBOT_ID", "TEAM_GONE", "PlannerSpec",
+    "PlannerRoundRequest", "PlannerRobot", "PlannerMember", "PlannerObservation", "PlannerPlanIn", "PlannerRound",
+    "PlannerPlans", "PlannerPlansWritten", "PlanAppend", "PlanAppended", "PlannerObserve", "PlannerObserved",
 
     "TEMPLATE_SCHEME", "parse_template",
 

{sequence_base-0.5.1 → sequence_base-0.6.0}/sequence_base/contract/connect.py

@@ -16,9 +16,8 @@ from pydantic import BaseModel, ConfigDict, Field, model_validator
 
 
 from sequence_base.contract.errors import WarmingError
-from sequence_base.contract.own_io import Observations
+from sequence_base.contract.planner import TEAM_GONE
 from sequence_base.contract.retired import dropped
-from sequence_base.contract.team import check_name
 
 __all__ = ["Lease", "ConnectRequest", "ConnectResponse", "Standby", "WarmingError"]
 
@@ -47,34 +46,15 @@ class ConnectRequest(BaseModel):
 
 
     switched: bool = Field(default=False, description="this robot just switched to the standby copy it was handed")
-
-
-
-
-    team: str | None = Field(default=None, description="the team this robot joins, by name")
-    group: str | None = Field(default=None, description="its group in that team; None: the default group")
-
-
-
-    team_key: str | None = Field(default=None, max_length=256,
-                                 description="a team key of the group it joins (seq_team_…); its group is the key's")
-
     @model_validator(mode="before")
     @classmethod
     def _retired(cls, data: Any) -> Any:
-        return dropped(data, "embodiment")
 
-    @model_validator(mode="after")
-    def _a_group_is_a_teams(self) -> "ConnectRequest":
-        if self.team is not None:
-            check_name(self.team, "team")
-        if self.group is not None:
-            if self.team is None:
-                raise ValueError("a group is a team's: say the team too")
-            check_name(self.group, "group")
-        if self.team_key is not None and self.team is None:
-            raise ValueError("a team key is a team's: say the team too")
-        return self
+
+
+        if isinstance(data, dict) and any(data.get(k) is not None for k in ("team", "group", "team_key")):
+            raise ValueError(TEAM_GONE)
+        return dropped(data, "embodiment", "team", "group", "team_key")
 
 
 class Standby(BaseModel):
@@ -118,9 +98,6 @@ class ConnectResponse(BaseModel):
     io: str | None = None
 
 
-    observations: Observations | None = None
-
-
     standby: Standby | None = None
 
 
@@ -133,4 +110,5 @@ class ConnectResponse(BaseModel):
     @classmethod
     def _retired(cls, data: Any) -> Any:
 
-        return dropped(data, "embodiment", "feedback", "action", "observation", "actions")
+
+        return dropped(data, "embodiment", "feedback", "action", "observation", "actions", "observations")

{sequence_base-0.5.1 → sequence_base-0.6.0}/sequence_base/contract/deployments.py

@@ -21,9 +21,9 @@ from typing import Any, Literal
 from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
 
 from sequence_base.contract.accounts import SecretRef
-from sequence_base.contract.own_io import Observations, Tensors
+from sequence_base.contract.own_io import Tensors, observations_gone
+from sequence_base.contract.planner import PLAN_ON_A_POLICY, PlannerSpec, team_gone
 from sequence_base.contract.retired import dropped
-from sequence_base.contract.team import TeamSpec
 from sequence_base.contract.policy import (
     KIND_NAME,
     SCALING_RETIRED,
@@ -185,7 +185,8 @@ class DeploymentPolicy(BaseModel):
     @model_validator(mode="before")
     @classmethod
     def _retired(cls, data: Any) -> Any:
-        return dropped(data, "embodiments", "feedback", "action", "observation", "action_declared", "actions")
+        return dropped(team_gone(observations_gone(data)), "embodiments", "feedback", "action", "observation",
+                       "action_declared", "actions")
 
     handler_ref: str
 
@@ -219,26 +220,27 @@ class DeploymentPolicy(BaseModel):
     models: list[str] | None = Field(default=None, max_length=16)
 
 
-
-
     plan_every_s: float | None = Field(default=None, gt=0)
 
 
-    observations: Observations | None = None
     tensors: Tensors | None = None
 
 
-    team: TeamSpec | None = None
+
+
+    planner: PlannerSpec | None = None
 
     @model_validator(mode="after")
-    def _team_answers_no_act(self) -> "DeploymentPolicy":
-        if self.team is not None:
-            said = [name for name in ("hz", "action_chunk_len", "action_chunk_exec_len", "observations", "tensors")
+    def _planner_answers_no_act(self) -> "DeploymentPolicy":
+        if self.planner is not None:
+            said = [name for name in ("hz", "action_chunk_len", "action_chunk_exec_len", "tensors")
                     if getattr(self, name) is not None]
             if said:
-                raise ValueError(f"a team answers no act, so it declares no {', '.join(said)}")
+                raise ValueError(f"a planner answers no act, so it declares no {', '.join(said)}")
             if self.plan_every_s is None:
-                raise ValueError("a team plans: its policy block says plan_every_s")
+                raise ValueError("a planner plans: its policy block says plan_every_s")
+        elif self.plan_every_s is not None:
+            raise ValueError(PLAN_ON_A_POLICY)
         return self
 
     @model_validator(mode="after")

{sequence_base-0.5.1 → sequence_base-0.6.0}/sequence_base/contract/observe.py

@@ -14,8 +14,7 @@ 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 fed every observation since its last act (Observations(every=1); own_observations "since_last_act" until
-contract 0.5.25).
+a policy handed every observation as its robot sends it (an @seq.observe method's, or the newest kept for its act).
 
 """
 from __future__ import annotations
@@ -24,7 +23,8 @@ from typing import Any
 
 from pydantic import BaseModel, ConfigDict, Field
 
-__all__ = ["FORMAT", "FRAMES_MISSING", "FRAMES_OVER_LIMIT", "ObserveFrame", "ObserveRequest", "ObserveResponse"]
+__all__ = ["FORMAT", "FRAMES_MISSING", "FRAMES_OVER_LIMIT", "ObserveFrame", "ObserveRequest", "ObserveResponse",
+           "ZSTD_FORMAT"]
 
 
 
@@ -33,6 +33,11 @@ FORMAT = "x-seq-observe/1"
 
 
 
+ZSTD_FORMAT = "x-seq-zstd/1"
+
+
+
+
 FRAMES_MISSING = "frames_missing"
 FRAMES_OVER_LIMIT = "frames_over_limit"
 

sequence_base-0.6.0/sequence_base/contract/own_io.py

@@ -0,0 +1,97 @@
+"""
+What a policy of its own inputs declares (contract 0.5.24): whether its inputs reach it as torch tensors - and what an
+eval plays of its answers (rows_of). A policy that declares nothing is sent and handed what it is today.
+
+`observations=seq.Observations(...)` and `seq.Stream(...)`, which said which keys of an observation a policy read at
+which steps, are gone: a policy is handed every observation as its robot sends it, and one that reads more than the
+newest keeps them in an @seq.observe method (on self, or in episode.state). A spec or a deploy that still declares them
+is refused (OBSERVATIONS_GONE); one stored with `observations: null` reads as it did.
+
+
+"""
+from __future__ import annotations
+
+import numbers
+from collections.abc import Mapping
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+from sequence_base.contract.retired import dropped
+
+__all__ = ["OBSERVATIONS_GONE", "Tensors", "observations_gone", "rows_of"]
+
+
+OBSERVATIONS_GONE = ("observations= is gone: a policy is handed every observation as its robot sends it - keep the ones "
+                     "an act reads in an @seq.observe method (on self, or in episode.state), and deploy again with the "
+                     "latest sequence-ai")
+
+
+def observations_gone(data: Any) -> Any:
+    """A model's before-validator for a body that may name `observations`: refused (OBSERVATIONS_GONE) when it declares
+    some, read without it when it is null - as a spec stored before it went holds it."""
+    if isinstance(data, dict) and data.get("observations") is not None:
+        raise ValueError(OBSERVATIONS_GONE)
+    return dropped(data, "observations")
+
+
+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
+    the policy's code."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    batch: bool = True
+
+
+def rows_of(answer: Any, actions: Any = None) -> list:
+    """The rows of a policy's own answer that play, in order, as an eval's adapter reads them. `actions`: what its
+    caller says of the rows, a dict or an object - 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`. Without it, 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 turn it into actions in an adapter - 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 holds 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): turn it into actions in an adapter")