sequence-base 0.4.28__tar.gz → 0.4.30__tar.gz

{sequence_base-0.4.28 → sequence_base-0.4.30}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "sequence-base"
-version = "0.4.28"
+version = "0.4.30"
 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.28 → sequence_base-0.4.30}/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.30/sequence_base/by_name.py

@@ -0,0 +1,90 @@
+"""
+Which arguments of a method a policy class names (infer=, observe=) an act's inputs fill: the inputs whole, its one
+argument - or, when it takes two or more without a default, each key of the inputs to its argument of that name.
+
+In one sentence: `takes_by_name(parameters, platform)` reads the method's arguments - less *args, **kwargs and the ones
+the platform hands it itself (`platform`: INFER_PLATFORM, OBSERVE_PLATFORM) → two or more of them without a default:
+it takes its inputs by name (ByName), each of its arguments a key - one without a default a key the inputs must hold,
+one with a default a key they may → `ByName.call(inputs, what)` makes what it is called with, refusing inputs that are
+no dict, lack a key it needs, or hold one it takes no argument for (unless it takes **kwargs), each named; fewer than
+two: None, the inputs go to its first argument whole and its others with a default are inference parameters, as before.
+
+WHY by the arguments without a default: a method that needs two or more could never be handed an act's inputs whole -
+the platform refused to deploy one - so binding them by name changes nothing a class deployed today does, and a method
+that takes one beside its inference parameters keeps taking its inputs whole. The SDK reads the rule when a class is
+declared (seq/named.py, registry.infer_params), the worker when it calls the method (harness/handler/loader.py): one
+rule on both sides.
+"""
+from __future__ import annotations
+
+import inspect
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass
+from typing import Any
+
+__all__ = ["INFER_PLATFORM", "OBSERVE_PLATFORM", "ByName", "takes_by_name"]
+
+
+
+INFER_PLATFORM = frozenset({"seed", "episode_id", "episode", "feedback", "plan", "robot", "embodiment"})
+OBSERVE_PLATFORM = frozenset({"step"})
+
+_VARIADIC = (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD)
+
+
+@dataclass(frozen=True)
+class ByName:
+    """A method that takes an act's inputs by name: `names`, the arguments they fill, in order; `required`, those with
+    no default; `positional`, those it takes by position only (before a `/`); `rest`, whether it takes **kwargs - any
+    other key of the inputs going there; `platform`, the names the platform hands it itself."""
+
+    names: tuple[str, ...]
+    required: tuple[str, ...]
+    positional: tuple[str, ...]
+    rest: bool
+    platform: frozenset[str]
+
+    def call(self, inputs: Any, what: str) -> tuple[list, dict]:
+        """(args, kwargs) the method `what` ("Model.predict") is called with for an act's `inputs`; ValueError, in its
+        words, for inputs that are not a dict of its arguments."""
+        takes = ", ".join(n if n in self.required else f"{n} (optional)" for n in self.names)
+        if not isinstance(inputs, Mapping):
+            raise ValueError(f"{what} takes its inputs by name ({takes}): an act's inputs are a dict of them, and "
+                             f"these are a {type(inputs).__name__}")
+        missing = [n for n in self.required if n not in inputs]
+        extra = [k for k in inputs if k not in self.names
+                 and not (self.rest and isinstance(k, str) and k not in self.platform)]
+        if missing or extra:
+            held = f"lack {_keys(missing)}" if missing else ""
+            if extra:
+                held += (" and " if held else "") + f"hold {_keys(extra)}, which it takes no argument for"
+            ours = [k for k in extra if k in self.platform]
+            mine = f" ({_keys(ours)}: the platform's to hand it)" if ours else ""
+            raise ValueError(f"{what} takes its inputs by name ({takes}), and these {held}{mine}")
+        args: list = []
+        for i, name in enumerate(self.positional):
+            if name not in inputs:
+                later = next((n for n in self.positional[i + 1:] if n in inputs), None)
+                if later is not None:
+                    raise ValueError(f"{what} takes {name} and {later} by position only, in that order: these hold "
+                                     f"{later!r} and no {name!r}")
+                break
+            args.append(inputs[name])
+        return args, {k: v for k, v in inputs.items() if k not in self.positional}
+
+
+def takes_by_name(parameters: Iterable[inspect.Parameter], platform: frozenset[str] = frozenset()) -> ByName | None:
+    """How a method of these `parameters` (self left out) takes an act's inputs: by name (ByName) when two or more of
+    its arguments - *args, **kwargs and `platform`'s left out - have no default, else None: whole, as one argument."""
+    every = list(parameters)
+    params = [p for p in every if p.kind not in _VARIADIC and p.name not in platform]
+    required = tuple(p.name for p in params if p.default is inspect.Parameter.empty)
+    if len(required) < 2:
+        return None
+    return ByName(names=tuple(p.name for p in params), required=required,
+                  positional=tuple(p.name for p in params if p.kind is inspect.Parameter.POSITIONAL_ONLY),
+                  rest=any(p.kind is inspect.Parameter.VAR_KEYWORD for p in every), platform=frozenset(platform))
+
+
+def _keys(names: list) -> str:
+    return ", ".join(repr(n) for n in names)

{sequence_base-0.4.28 → sequence_base-0.4.30}/sequence_base/constants/version.py

@@ -4,7 +4,9 @@
 
 
 
-CONTRACT_VERSION = "0.5.25"
+CONTRACT_VERSION = "0.5.27"
+
+
 
 
 

{sequence_base-0.4.28 → sequence_base-0.4.30}/sequence_base/construct.py

@@ -1,10 +1,12 @@
 """
 How a policy class that names its own methods is built (PolicyRegistration.constructor): its constructor - or the
-factory it names - called with the arguments its decorator was given, once two forms in them are filled in.
+factory it names, a classmethod of it or a module's function - called with the arguments its decorator was given, once
+two forms in them are filled in.
 
 In one sentence: a value {"$config": path, "$set": {...}} becomes the YAML or JSON file at `path` - from the folder of
 the class's file - read where the policy runs, with `$set`'s keys laid over its top level → in every string,
 "{weights}" becomes the weights directory and "{weights.<part>}" a named part's → `cls.<make>(*args, **kwargs)`, or
+`function(*args, **kwargs)` for make="package.module:function" - the module imported where the policy runs - or
 `cls(*args, **kwargs)` without a factory.
 
 WHY a config file is read where the policy runs: it is part of the project (XPolicyLab's deploy.yml beside its
@@ -14,12 +16,14 @@ worker's directory.
 """
 from __future__ import annotations
 
+import importlib
 import json
 import os
 import re
 from typing import Any
 
-__all__ = ["CONFIG_KEY", "SET_KEY", "ConstructError", "build", "config", "expand", "is_config", "read_config"]
+__all__ = ["CONFIG_KEY", "SET_KEY", "ConstructError", "build", "config", "expand", "is_config", "maker",
+           "read_config"]
 
 CONFIG_KEY, SET_KEY = "$config", "$set"
 _WEIGHTS = re.compile(r"\{weights(?:\.([A-Za-z_][A-Za-z0-9_-]*))?\}")
@@ -96,8 +100,25 @@ def _weights_of(part: str | None, weights: Any) -> str:
 
 
 def build(cls: type, constructor: Any, *, base_dir: str, weights: Any) -> Any:
-    """The instance `constructor` (a PolicyConstructor) makes of `cls`: `cls.<make>(*args, **kwargs)` or `cls(...)`."""
+    """The instance `constructor` (a PolicyConstructor) makes of `cls`: `cls.<make>(*args, **kwargs)`, the function
+    make="package.module:function" names called so, or `cls(...)`."""
     args = expand(list(constructor.args), base_dir=base_dir, weights=weights)
     kwargs = expand(dict(constructor.kwargs), base_dir=base_dir, weights=weights)
-    make = getattr(cls, constructor.make) if constructor.make else cls
-    return make(*args, **kwargs)
+    return maker(cls, constructor.make)(*args, **kwargs)
+
+
+def maker(cls: type, make: str | None) -> Any:
+    """What builds the instance: `cls` for no make=, its classmethod or staticmethod `make`, or - make written
+    "package.module:function" - that module's function, the module imported (as the policy's code imports it).
+    """
+    if not make:
+        return cls
+    module, colon, name = make.rpartition(":")
+    if not colon:
+        return getattr(cls, make)
+    found = getattr(importlib.import_module(module), name, None)
+    if found is None:
+        raise ConstructError(f"make={make!r}: {module} has no function {name!r}")
+    if not callable(found):
+        raise ConstructError(f"make={make!r}: {module}.{name} is not callable ({type(found).__name__})")
+    return found

{sequence_base-0.4.28 → sequence_base-0.4.30}/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.28 → sequence_base-0.4.30}/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)
 
 

{sequence_base-0.4.28 → sequence_base-0.4.30}/sequence_base/contract/own_io.py

@@ -163,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

{sequence_base-0.4.28 → sequence_base-0.4.30}/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
@@ -478,19 +482,26 @@ def check_weights_parts(weights_name: str | None, extra: dict) -> None:
         raise ValueError(f"at most {MAX_WEIGHTS_PARTS} weights parts")
 
 
+
+_MAKE = r"^(?:[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*:)?[A-Za-z_][A-Za-z0-9_]*$"
+
+
 class PolicyConstructor(BaseModel):
     """How the worker builds a policy class that names its own methods (`@seq.policy(infer="get_action", ...)`): its
-    own constructor, or the factory it names (`make`, e.g. LeRobot's `from_pretrained`), called with `args` and
-    `kwargs` where `@seq.load` would run - the replica's cold start, the weights on disk. The values are the user's own,
-    as JSON carries them, but for two forms the worker fills in first (sequence_base.construct.expand): a config file's
-    contents, `{"$config": <its path from the class's file>, "$set": {<keys laid over it>}}`, YAML or JSON, and in any
-    string `"{weights}"` (the weights directory) or `"{weights.<part>}"` (a named part's).
+    own constructor, or the factory it names (`make`: a classmethod of it, e.g. LeRobot's `from_pretrained`, or a
+    module's function, "package.module:function", whose return is the instance its methods are called on), called
+    with `args` and `kwargs` where `@seq.load` would run - the replica's cold start, the weights on disk. The values are
+    the user's own, as JSON carries them, but for two forms the worker fills in first (sequence_base.construct.expand):
+    a config file's contents, `{"$config": <its path from the class's file>, "$set": {<keys laid over it>}}`, YAML or
+    JSON, and in any string `"{weights}"` (the weights directory) or `"{weights.<part>}"` (a named part's).
+
 """
 
     model_config = ConfigDict(extra="forbid")
 
-    make: str | None = Field(default=None, pattern=r"^[A-Za-z_][A-Za-z0-9_]*$",
-                             description="a classmethod or staticmethod that returns the instance; None: the class")
+    make: str | None = Field(default=None, max_length=512, pattern=_MAKE,
+                             description="a classmethod or staticmethod that returns the instance, or a module's "
+                                         "function, 'package.module:function' (contract 0.5.27); None: the class")
     args: list[Any] = Field(default_factory=list, description="positional arguments, in order")
     kwargs: dict[str, Any] = Field(default_factory=dict, description="keyword arguments")
 

{sequence_base-0.4.28 → sequence_base-0.4.30}/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.30/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.28 → sequence_base-0.4.30}/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.28 → sequence_base-0.4.30}/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.25"
+  "x-contract-version": "0.5.27"
 }

{sequence_base-0.4.28 → sequence_base-0.4.30}/sequence_base/schemas/ActResponse.json

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

{sequence_base-0.4.28 → sequence_base-0.4.30}/sequence_base/schemas/ActionChunk.json

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

{sequence_base-0.4.28 → sequence_base-0.4.30}/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.25"
+  "x-contract-version": "0.5.27"
 }

{sequence_base-0.4.28 → sequence_base-0.4.30}/sequence_base/schemas/ActionStep.json

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

{sequence_base-0.4.28 → sequence_base-0.4.30}/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.25"
+  "x-contract-version": "0.5.27"
 }

{sequence_base-0.4.28 → sequence_base-0.4.30}/sequence_base/schemas/AdapterPair.json

@@ -17,5 +17,5 @@
   ],
   "title": "AdapterPair",
   "type": "object",
-  "x-contract-version": "0.5.25"
+  "x-contract-version": "0.5.27"
 }

{sequence_base-0.4.28 → sequence_base-0.4.30}/sequence_base/schemas/AddLocal.json

@@ -23,5 +23,5 @@
   ],
   "title": "AddLocal",
   "type": "object",
-  "x-contract-version": "0.5.25"
+  "x-contract-version": "0.5.27"
 }

{sequence_base-0.4.28 → sequence_base-0.4.30}/sequence_base/schemas/Autoscaler.json

@@ -57,5 +57,5 @@
   },
   "title": "Autoscaler",
   "type": "object",
-  "x-contract-version": "0.5.25"
+  "x-contract-version": "0.5.27"
 }

{sequence_base-0.4.28 → sequence_base-0.4.30}/sequence_base/schemas/BenchmarkConditionSpec.json

@@ -50,5 +50,5 @@
   ],
   "title": "BenchmarkConditionSpec",
   "type": "object",
-  "x-contract-version": "0.5.25"
+  "x-contract-version": "0.5.27"
 }

{sequence_base-0.4.28 → sequence_base-0.4.30}/sequence_base/schemas/BenchmarkRegisterRequest.json

@@ -11,6 +11,18 @@
         "action_space": {
           "$ref": "#/$defs/ActionSpace"
         },
+        "aligned": {
+          "anyOf": [
+            {
+              "type": "boolean"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Aligned"
+        },
         "bounds": {
           "anyOf": [
             {
@@ -1077,5 +1089,5 @@
   ],
   "title": "BenchmarkRegisterRequest",
   "type": "object",
-  "x-contract-version": "0.5.25"
+  "x-contract-version": "0.5.27"
 }

{sequence_base-0.4.28 → sequence_base-0.4.30}/sequence_base/schemas/BenchmarkSpec.json

@@ -471,7 +471,7 @@
       ],
       "title": "SeqFlags",
       "type": "integer",
-      "x-contract-version": "0.5.25",
+      "x-contract-version": "0.5.27",
       "x-flag-names": {
         "CHECK": 65536,
         "INFER": 16,
@@ -722,5 +722,5 @@
   ],
   "title": "BenchmarkSpec",
   "type": "object",
-  "x-contract-version": "0.5.25"
+  "x-contract-version": "0.5.27"
 }

{sequence_base-0.4.28 → sequence_base-0.4.30}/sequence_base/schemas/BenchmarkStatusResponse.json

@@ -40,5 +40,5 @@
   ],
   "title": "BenchmarkStatusResponse",
   "type": "object",
-  "x-contract-version": "0.5.25"
+  "x-contract-version": "0.5.27"
 }

{sequence_base-0.4.28 → sequence_base-0.4.30}/sequence_base/schemas/BootstrapResponse.json

@@ -79,5 +79,5 @@
   ],
   "title": "BootstrapResponse",
   "type": "object",
-  "x-contract-version": "0.5.25"
+  "x-contract-version": "0.5.27"
 }

{sequence_base-0.4.28 → sequence_base-0.4.30}/sequence_base/schemas/Camera.json

@@ -122,5 +122,5 @@
   ],
   "title": "Camera",
   "type": "object",
-  "x-contract-version": "0.5.25"
+  "x-contract-version": "0.5.27"
 }

{sequence_base-0.4.28 → sequence_base-0.4.30}/sequence_base/schemas/CodeBundle.json

@@ -23,5 +23,5 @@
   ],
   "title": "CodeBundle",
   "type": "object",
-  "x-contract-version": "0.5.25"
+  "x-contract-version": "0.5.27"
 }

{sequence_base-0.4.28 → sequence_base-0.4.30}/sequence_base/schemas/Concurrency.json

@@ -96,5 +96,5 @@
   },
   "title": "Concurrency",
   "type": "object",
-  "x-contract-version": "0.5.25"
+  "x-contract-version": "0.5.27"
 }

{sequence_base-0.4.28 → sequence_base-0.4.30}/sequence_base/schemas/Conditions.json

@@ -55,5 +55,5 @@
   ],
   "title": "Conditions",
   "type": "object",
-  "x-contract-version": "0.5.25"
+  "x-contract-version": "0.5.27"
 }

{sequence_base-0.4.28 → sequence_base-0.4.30}/sequence_base/schemas/ConnectRequest.json

@@ -25,5 +25,5 @@
   ],
   "title": "ConnectRequest",
   "type": "object",
-  "x-contract-version": "0.5.25"
+  "x-contract-version": "0.5.27"
 }