sequence-base 0.4.23__tar.gz → 0.4.25__tar.gz

{sequence_base-0.4.23 → sequence_base-0.4.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sequence-base
-Version: 0.4.23
+Version: 0.4.25
 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
@@ -12,3 +12,4 @@ Provides-Extra: test
 Requires-Dist: hypothesis>=6; extra == 'test'
 Requires-Dist: jsonschema>=4; extra == 'test'
 Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pyyaml; extra == 'test'

{sequence_base-0.4.23 → sequence_base-0.4.25}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sequence-base"
-version = "0.4.23"
+version = "0.4.25"
 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"]
@@ -10,7 +10,7 @@ Changelog = "https://generalsequences.com/docs/changelog/"
 
 [project.optional-dependencies]
 codec = ["pillow>=10", "numpy>=1.26"]
-test = ["pytest", "jsonschema>=4", "hypothesis>=6"]
+test = ["pytest", "jsonschema>=4", "hypothesis>=6", "pyyaml"]
 
 [build-system]
 requires = ["hatchling"]

{sequence_base-0.4.23 → sequence_base-0.4.25}/sequence_base/__init__.py

@@ -76,6 +76,7 @@ from sequence_base.contract import (
     Lease,
     MetricAgg,
     Observation,
+    PolicyConstructor,
     PolicyRegistration,
     PolicySpec,
     Proprioception,
@@ -132,7 +133,7 @@ __all__ = [
     "SeqFlags", "ImageStepUvPip", "ImageStepApt", "ImageStepEnv", "ImageStepRun", "AddLocal", "ImageStepAddLocal",
     "FROZEN_PATH", "TemplateFiles", "ImageStepTemplateFiles", "ImageStep", "ImageSpec",
     "VolumeMount", "VolumeRef", "Concurrency", "ActionContract", "Camera", "ObservationContract", "Embodiment",
-    "PolicySpec", "PolicyRegistration",
+    "PolicySpec", "PolicyRegistration", "PolicyConstructor",
 
     "MAX_CODE_BUNDLE_BYTES", "CodeBundle",
     "Resources", "Autoscaler", "Timeouts", "DeploymentPolicy", "InferParam", "DeploymentRequest",

{sequence_base-0.4.23 → sequence_base-0.4.25}/sequence_base/constants/version.py

@@ -4,7 +4,9 @@
 
 
 
-CONTRACT_VERSION = "0.5.20"
+CONTRACT_VERSION = "0.5.22"
+
+
 
 
 

sequence_base-0.4.25/sequence_base/construct.py

@@ -0,0 +1,103 @@
+"""
+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.
+
+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
+`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
+model.py) and goes up with it, so one copy - the one the policy runs with - is read, and "{weights}" in it means the
+worker's directory.
+
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+from typing import Any
+
+__all__ = ["CONFIG_KEY", "SET_KEY", "ConstructError", "build", "config", "expand", "is_config", "read_config"]
+
+CONFIG_KEY, SET_KEY = "$config", "$set"
+_WEIGHTS = re.compile(r"\{weights(?:\.([A-Za-z_][A-Za-z0-9_-]*))?\}")
+
+
+class ConstructError(ValueError):
+    """Arguments that cannot be filled in: a config file missing, unreadable or of another kind, or a weights
+    placeholder with no weights - or no such part - to fill it."""
+
+
+def config(path: str, **overrides: Any) -> dict:
+    """A config file's contents with `overrides` laid over its top level, as the worker reads it (`seq.config`)."""
+    if not isinstance(path, str) or not path:
+        raise ConstructError("a config file is a path, from the folder of the class's file")
+    if os.path.isabs(path):
+        raise ConstructError(f"{path}: give a config file's path from the folder of the class's file - the policy runs "
+                             "it where the upload puts it")
+    return {CONFIG_KEY: path, SET_KEY: dict(overrides)}
+
+
+def is_config(value: Any) -> bool:
+    return isinstance(value, dict) and set(value) == {CONFIG_KEY, SET_KEY} and isinstance(value[CONFIG_KEY], str)
+
+
+def read_config(path: str) -> Any:
+    """The YAML (.yml, .yaml) or JSON (.json) file at `path`."""
+    kind = os.path.splitext(path)[1].lower()
+    if kind not in (".json", ".yml", ".yaml"):
+        raise ConstructError(f"{path}: a config file is .json, .yml or .yaml")
+    if not os.path.isfile(path):
+        raise ConstructError(f"{path}: no such config file")
+    with open(path, encoding="utf-8") as f:
+        if kind == ".json":
+            return json.load(f)
+        try:
+            import yaml
+        except ImportError:
+            raise ConstructError(f"{path}: reading YAML needs pyyaml") from None
+        return yaml.safe_load(f)
+
+
+def expand(value: Any, *, base_dir: str, weights: Any) -> Any:
+    """`value` with its config files read (from `base_dir`) and its weights placeholders filled from `weights` - the
+    weights directory, or {part: directory} for named parts, or None for a policy without weights."""
+    if is_config(value):
+        loaded = read_config(os.path.join(base_dir, value[CONFIG_KEY]))
+        if value[SET_KEY] and not isinstance(loaded, dict):
+            raise ConstructError(f"{value[CONFIG_KEY]} holds a {type(loaded).__name__}, which has no keys to set")
+        merged = {**loaded, **value[SET_KEY]} if isinstance(loaded, dict) else loaded
+        return expand(merged, base_dir=base_dir, weights=weights)
+    if isinstance(value, dict):
+        return {k: expand(v, base_dir=base_dir, weights=weights) for k, v in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [expand(v, base_dir=base_dir, weights=weights) for v in value]
+    if isinstance(value, str):
+        return _WEIGHTS.sub(lambda m: _weights_of(m.group(1), weights), value)
+    return value
+
+
+def _weights_of(part: str | None, weights: Any) -> str:
+    if weights is None:
+        raise ConstructError("{weights} names the weights directory, and this policy declares no weights=")
+    if isinstance(weights, dict):
+        if part is None:
+            raise ConstructError(f"its weights come in named parts ({', '.join(sorted(weights))}): name one, "
+                                 f"{{weights.<part>}}")
+        if part not in weights:
+            raise ConstructError(f"{{weights.{part}}}: its weights have no part {part!r} "
+                                 f"({', '.join(sorted(weights))})")
+        return str(weights[part])
+    if part is not None:
+        raise ConstructError(f"{{weights.{part}}} names a part, and its weights come whole: {{weights}}")
+    return str(weights)
+
+
+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(...)`."""
+    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)

{sequence_base-0.4.23 → sequence_base-0.4.25}/sequence_base/contract/__init__.py

@@ -34,6 +34,7 @@ from sequence_base.contract.policy import (
     FROZEN_PATH,
     TemplateFiles,
     ImageStepTemplateFiles,
+    PolicyConstructor,
     PolicyRegistration,
     PolicySpec,
     VolumeMount,
@@ -121,7 +122,7 @@ __all__ = [
     "ImageStepUvPip", "ImageStepApt", "ImageStepEnv", "ImageStepRun", "AddLocal", "ImageStepAddLocal",
     "TemplateFiles", "ImageStepTemplateFiles", "FROZEN_PATH", "ImageStep", "ImageSpec",
     "VolumeMount", "VolumeRef", "Concurrency", "ActionContract", "Camera", "ObservationContract", "Embodiment",
-    "PolicySpec", "PolicyRegistration",
+    "PolicySpec", "PolicyRegistration", "PolicyConstructor",
 
     "MAX_CODE_BUNDLE_BYTES", "CodeBundle",
     "Resources", "Autoscaler", "Timeouts", "DeploymentPolicy", "InferParam", "DeploymentRequest",

{sequence_base-0.4.23 → sequence_base-0.4.25}/sequence_base/contract/benchmarks.py

@@ -210,6 +210,12 @@ class BenchmarkRegisterRequest(BaseModel):
     action_contract: ActionContract | None = None
 
 
+
+
+
+    freeze: bool | None = None
+
+
     secrets: list[SecretRef] = Field(default_factory=list)
 
 

{sequence_base-0.4.23 → sequence_base-0.4.25}/sequence_base/contract/deployments.py

@@ -202,6 +202,19 @@ class DeploymentPolicy(BaseModel):
 
     plan_every_s: float | None = Field(default=None, gt=0)
 
+
+
+
+    own_observations: Literal["latest", "since_last_act"] | None = None
+    own_actions: Literal["one", "steps"] | None = None
+
+    @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")
+        return self
+
     @model_validator(mode="after")
     def _param_names(self) -> "DeploymentPolicy":
         for name in self.params or {}:
@@ -283,6 +296,12 @@ class DeploymentRequest(BaseModel):
     weights_name: str | None = None
     extra_weights: dict[str, VolumeMount] | None = None
 
+
+
+
+
+    freeze: bool | None = None
+
     @field_validator("name")
     @classmethod
     def _name_is_a_slug(cls, v: str) -> str:

{sequence_base-0.4.23 → sequence_base-0.4.25}/sequence_base/contract/policy.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 
 import re
 
-from typing import Literal
+from typing import Any, Literal
 
 from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
 
@@ -357,10 +357,31 @@ def check_weights_parts(weights_name: str | None, extra: dict) -> None:
         raise ValueError(f"at most {MAX_WEIGHTS_PARTS} weights parts")
 
 
+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).
+"""
+
+    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")
+    args: list[Any] = Field(default_factory=list, description="positional arguments, in order")
+    kwargs: dict[str, Any] = Field(default_factory=dict, description="keyword arguments")
+
+
 class PolicyRegistration(BaseModel):
     """What the harness loader introspects: the spec, the SeqFlags→method-name bindings, and the
     `handler_ref` it importlib-loads the policy class from. From one of these the loader recovers which
-    method is which lifecycle entrypoint (load / infer / on_episode / plan …)."""
+    method is which lifecycle entrypoint (load / infer / on_episode / plan …).
+
+    A class that names its own methods (`constructor` set) is built by its constructor or factory, so it binds no LOAD,
+    and its bindings name its own methods: INFER (what answers an act), and as declared OBSERVE (each observation an
+    act carries, before INFER is called with none), RESET (an episode's first act) and ON_EPISODE (its end)."""
 
     model_config = ConfigDict(extra="forbid")
 
@@ -374,3 +395,16 @@ class PolicyRegistration(BaseModel):
     plan_every_s: float | None = Field(
         default=None, gt=0, description="Seconds between @seq.plan calls; set iff a PLAN binding exists"
     )
+
+    constructor: PolicyConstructor | None = None
+
+    @model_validator(mode="after")
+    def _built_by_its_constructor(self) -> "PolicyRegistration":
+        if self.constructor is not None:
+            if SeqFlags.LOAD in self.bindings:
+                raise ValueError("a policy built by its constructor (constructor) has no @seq.load: its constructor is "
+                                 "its load")
+            if SeqFlags.INFER not in self.bindings:
+                raise ValueError("a policy built by its constructor (constructor) names the method that answers an act "
+                                 "(an INFER binding)")
+        return self

{sequence_base-0.4.23 → sequence_base-0.4.25}/sequence_base/msgpack_io.py

@@ -6,7 +6,8 @@ Written in plain Python, so neither a worker nor a client installs a msgpack pac
 In one sentence: a client takes the act's envelope ({"inputs", "seed", "episode_id", "params", ...}) → `pack` writes it
 as msgpack, each numpy array as the map msgpack-numpy writes ({"nd": True, "type", "kind", "shape", "data"}) → a worker
 that names FORMAT among its formats `unpack`s it back to the same dict, arrays as arrays, and serves it as it serves a
-JSON act; an answer asked for in msgpack (Accept: MEDIA_TYPE) comes back the same way.
+JSON act; an answer asked for in msgpack (Accept: MEDIA_TYPE) comes back the same way - its arrays, to a client
+without numpy, as the lists their tolist() gives, what the answer in JSON holds.
 
 WHY a media type of its own: a worker reads a body that is not JSON as the policy's own inputs and hands it on
 untouched - an `application/msgpack` body included, which some policies decode themselves - so a client sends this
@@ -24,8 +25,10 @@ anything.
 """
 from __future__ import annotations
 
+import re
 import struct
-from typing import Any
+import sys
+from typing import Any, NamedTuple
 
 __all__ = ["FORMAT", "MAX_DEPTH", "MEDIA_TYPE", "MsgpackError", "pack", "unpack"]
 
@@ -154,9 +157,10 @@ def _readable_dtype(dtype) -> None:
 
 
 def unpack(data: bytes) -> Any:
-    """The one msgpack value `data` holds, numpy arrays (msgpack-numpy's or openpi's layout) back as read-only arrays.
-    MsgpackError: truncated, more than one value, an extension type, nested past MAX_DEPTH, a length past the body, or
-    an array whose dtype holds objects."""
+    """The one msgpack value `data` holds, numpy arrays (msgpack-numpy's or openpi's layout) back as read-only arrays -
+    or, where numpy is not installed, as the nested lists of plain values their tolist() gives, what a JSON answer
+    holds. MsgpackError: truncated, more than one value, an extension type, nested past MAX_DEPTH, a length past the
+    body, or an array whose dtype holds objects."""
     view = memoryview(bytes(data)) if not isinstance(data, bytes) else memoryview(data)
     value, at = _Reader(view).read(0, 0)
     if at != len(view):
@@ -284,12 +288,13 @@ def _array_of(m: dict) -> Any:
         dtype, data = _dtype(_field(m, "type")), _field(m, "data")
         if not isinstance(data, bytes) or len(data) != dtype.itemsize:
             raise MsgpackError(f"a numpy {dtype} scalar whose data is not {dtype.itemsize} bytes")
-        return _numpy().frombuffer(data, dtype=dtype, count=1)[0]
+        np = _numpy()
+        return _plain_items(dtype, data, 1)[0] if np is None else np.frombuffer(data, dtype=dtype, count=1)[0]
     if generic is True and has("dtype", "data"):
         dtype, value = _dtype(_field(m, "dtype")), _field(m, "data")
         if not isinstance(value, (bool, int, float, str, bytes)):
             raise MsgpackError("a numpy scalar's map whose data is not a plain value")
-        return dtype.type(value)
+        return value if _numpy() is None else dtype.type(value)
     return m
 
 
@@ -298,31 +303,118 @@ def _array(descr, shape, data):
     if not isinstance(shape, list) or not all(isinstance(d, int) and not isinstance(d, bool) and d >= 0
                                               for d in shape) or not isinstance(data, bytes):
         raise MsgpackError("a numpy array's map without a shape of non-negative ints or its data as bytes")
+    if len(shape) > _MAX_DIMS:
+        raise MsgpackError(f"a numpy array of {len(shape)} dimensions: numpy's own are {_MAX_DIMS} at most")
     count = 1
     for d in shape:
         count *= d
     if len(data) != count * dtype.itemsize:
         raise MsgpackError(f"a numpy array of shape {shape} and dtype {dtype} is {count * dtype.itemsize} bytes; its "
                            f"data is {len(data)}")
-    return _numpy().frombuffer(data, dtype=dtype, count=count).reshape(shape)
+    np = _numpy()
+    if np is None:
+        return _nested(_plain_items(dtype, data, count), shape)
+    return np.frombuffer(data, dtype=dtype, count=count).reshape(shape)
+
+
+
+_MAX_DIMS = 64
 
 
 def _numpy():
+    """numpy, or None where it is not installed: its arrays are then read as plain values (_Plain)."""
     try:
         import numpy
     except ImportError:
-        raise MsgpackError("this body holds numpy arrays, and numpy is not installed here") from None
+        return None
     return numpy
 
 
 def _dtype(descr):
-    np = _numpy()
+    """`descr`, an array's type string, as numpy's dtype - or, where numpy is not installed, as a _Plain read here.
+    MsgpackError for one that holds objects, a structured one, and one that is not a type string."""
     if not isinstance(descr, (str, bytes)):
         raise MsgpackError("a numpy array's dtype is not a type string: a structured array is not carried, only "
                            "plain numeric, bool and string dtypes are")
+    np = _numpy()
+    if np is None:
+        return _plain(_text(descr))
     try:
         dtype = np.dtype(_text(descr))
     except TypeError:
         raise MsgpackError(f"not a numpy dtype: {_text(descr)!r}") from None
     _readable_dtype(dtype)
     return dtype
+
+
+
+
+
+
+
+
+class _Plain(NamedTuple):
+    """An array's type string ('<f4', '|u1', '<U5' - numpy's dtype.str) read without numpy: struct's byte order, the
+    kind (numpy's letter) and one item's size in bytes."""
+    text: str
+    order: str
+    kind: str
+    itemsize: int
+
+    def __str__(self) -> str:
+        return self.text
+
+
+
+
+_STRUCT = {("b", 1): "?", ("i", 1): "b", ("i", 2): "h", ("i", 4): "i", ("i", 8): "q", ("u", 1): "B", ("u", 2): "H",
+           ("u", 4): "I", ("u", 8): "Q", ("f", 2): "e", ("f", 4): "f", ("f", 8): "d", ("c", 8): "f", ("c", 16): "d"}
+_TYPE = re.compile(r"([<>|=]?)([A-Za-z])(.*)", re.DOTALL)
+
+
+def _plain(text: str) -> _Plain:
+    """MsgpackError for a type string that holds objects or is structured - refused as with numpy - one whose items
+    are no bytes at all, and one only numpy reads (a long double, a date, a time span)."""
+    match = _TYPE.fullmatch(text)
+    order, kind, size = match.groups() if match else ("", "", "")
+    if kind in ("O", "V"):
+        raise MsgpackError(f"a numpy array of dtype {text} is not carried: only plain numeric, bool and string dtypes "
+                           "are")
+    n = int(size) if size.isascii() and size.isdigit() else -1
+    if kind in ("S", "U") and n == 0:
+        raise MsgpackError(f"a numpy array of dtype {text}, whose items are 0 bytes")
+    itemsize = 4 * n if kind == "U" else n
+    if not ((kind in ("S", "U") and n > 0) or (kind, itemsize) in _STRUCT):
+        raise MsgpackError(f"this body holds a numpy array of dtype {text}, which only numpy reads, and numpy is not "
+                           "installed here")
+    return _Plain(text, "<" if order in ("", "|") else order, kind, itemsize)
+
+
+def _plain_items(t: _Plain, data: bytes, count: int) -> list:
+    """`count` items of type `t` from `data`, as tolist() gives them: ints, floats, complexes and bools; bytes and
+    strs with their trailing NULs cut, as numpy cuts them."""
+    size = t.itemsize
+    if t.kind == "S":
+        return [data[i:i + size].rstrip(b"\x00") for i in range(0, count * size, size)]
+    if t.kind == "U":
+        big = t.order == ">" or (t.order == "=" and sys.byteorder == "big")
+        try:
+            return [str(data[i:i + size], "utf-32-be" if big else "utf-32-le").rstrip("\x00")
+                    for i in range(0, count * size, size)]
+        except UnicodeDecodeError:
+            raise MsgpackError(f"a numpy array of dtype {t} whose data is not UTF-32") from None
+    code = _STRUCT[(t.kind, size)]
+    if t.kind == "c":
+        parts = struct.unpack_from(f"{t.order}{2 * count}{code}", data)
+        return [complex(parts[i], parts[i + 1]) for i in range(0, 2 * count, 2)]
+    return list(struct.unpack_from(f"{t.order}{count}{code}", data))
+
+
+def _nested(flat: list, shape: list) -> Any:
+    """`flat`, in C order, as the nested lists of `shape`, as tolist() nests them - a 0-d array's one value as itself."""
+    if not shape:
+        return flat[0]
+    if len(shape) == 1:
+        return flat
+    step = len(flat) // shape[0] if shape[0] else 0
+    return [_nested(flat[i * step:(i + 1) * step], shape[1:]) for i in range(shape[0])]

{sequence_base-0.4.23 → sequence_base-0.4.25}/sequence_base/schemas/ActRequest.json

@@ -79,5 +79,5 @@
   ],
   "title": "ActRequest",
   "type": "object",
-  "x-contract-version": "0.5.20"
+  "x-contract-version": "0.5.22"
 }

{sequence_base-0.4.23 → sequence_base-0.4.25}/sequence_base/schemas/ActResponse.json

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

{sequence_base-0.4.23 → sequence_base-0.4.25}/sequence_base/schemas/ActionChunk.json

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

{sequence_base-0.4.23 → sequence_base-0.4.25}/sequence_base/schemas/ActionContract.json

@@ -84,5 +84,5 @@
   ],
   "title": "ActionContract",
   "type": "object",
-  "x-contract-version": "0.5.20"
+  "x-contract-version": "0.5.22"
 }

{sequence_base-0.4.23 → sequence_base-0.4.25}/sequence_base/schemas/ActionStep.json

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

{sequence_base-0.4.23 → sequence_base-0.4.25}/sequence_base/schemas/AdapterPair.json

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

{sequence_base-0.4.23 → sequence_base-0.4.25}/sequence_base/schemas/AddLocal.json

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

{sequence_base-0.4.23 → sequence_base-0.4.25}/sequence_base/schemas/Autoscaler.json

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

{sequence_base-0.4.23 → sequence_base-0.4.25}/sequence_base/schemas/BenchmarkConditionSpec.json

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

{sequence_base-0.4.23 → sequence_base-0.4.25}/sequence_base/schemas/BenchmarkRegisterRequest.json

@@ -809,6 +809,18 @@
       "default": null,
       "title": "Envs"
     },
+    "freeze": {
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": null,
+      "title": "Freeze"
+    },
     "gpu": {
       "anyOf": [
         {
@@ -974,5 +986,5 @@
   ],
   "title": "BenchmarkRegisterRequest",
   "type": "object",
-  "x-contract-version": "0.5.20"
+  "x-contract-version": "0.5.22"
 }

{sequence_base-0.4.23 → sequence_base-0.4.25}/sequence_base/schemas/BenchmarkSpec.json

@@ -379,7 +379,7 @@
       ],
       "title": "SeqFlags",
       "type": "integer",
-      "x-contract-version": "0.5.20",
+      "x-contract-version": "0.5.22",
       "x-flag-names": {
         "CHECK": 65536,
         "INFER": 16,
@@ -628,5 +628,5 @@
   ],
   "title": "BenchmarkSpec",
   "type": "object",
-  "x-contract-version": "0.5.20"
+  "x-contract-version": "0.5.22"
 }

{sequence_base-0.4.23 → sequence_base-0.4.25}/sequence_base/schemas/BenchmarkStatusResponse.json

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

{sequence_base-0.4.23 → sequence_base-0.4.25}/sequence_base/schemas/BootstrapResponse.json

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

{sequence_base-0.4.23 → sequence_base-0.4.25}/sequence_base/schemas/Camera.json

@@ -72,5 +72,5 @@
   ],
   "title": "Camera",
   "type": "object",
-  "x-contract-version": "0.5.20"
+  "x-contract-version": "0.5.22"
 }

{sequence_base-0.4.23 → sequence_base-0.4.25}/sequence_base/schemas/CodeBundle.json

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

{sequence_base-0.4.23 → sequence_base-0.4.25}/sequence_base/schemas/Concurrency.json

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

{sequence_base-0.4.23 → sequence_base-0.4.25}/sequence_base/schemas/Conditions.json

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

{sequence_base-0.4.23 → sequence_base-0.4.25}/sequence_base/schemas/ConnectRequest.json

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

{sequence_base-0.4.23 → sequence_base-0.4.25}/sequence_base/schemas/ConnectResponse.json

@@ -310,5 +310,5 @@
   ],
   "title": "ConnectResponse",
   "type": "object",
-  "x-contract-version": "0.5.20"
+  "x-contract-version": "0.5.22"
 }