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

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

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

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

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

sequence_base-0.5.1/sequence_base/construct.py

@@ -0,0 +1,173 @@
+"""
+How a class built by its constructor is built - a policy's or a team'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.
+
+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 class runs, with `$set`'s keys laid over its top level → in every string, a policy's
+"{weights}" becomes the weights directory and "{weights.<part>}" a named part's, a benchmark's "{num_worlds}" how many
+worlds this eval builds and "{policy.<field>}" what the evaluated policy declares (POLICY_FIELDS) - a string that is one
+form alone becomes its value as it is, an int or None, one among other text its value as text → `cls.<make>(*args,
+**kwargs)`, or `function(*args, **kwargs)` for make="package.module:function" - the module imported where the class
+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
+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.
+
+WHY a benchmark's too: its worlds are built after the machine's snapshot by the class's own constructor - a repository's
+env as it is, handed how many worlds and the policy's rate where its own code takes them - where a method of the
+platform's (@seq.setup) built them before.
+
+"""
+from __future__ import annotations
+
+import importlib
+import json
+import os
+import re
+from typing import Any
+
+__all__ = ["CONFIG_KEY", "FORMS", "POLICY_FIELDS", "SET_KEY", "ConstructError", "build", "config", "expand",
+           "is_config", "maker", "read_config"]
+
+CONFIG_KEY, SET_KEY = "$config", "$set"
+
+
+
+POLICY_FIELDS = ("hz", "action_chunk_len", "action_chunk_exec_len")
+
+
+FORMS = re.compile(r"\{(?:weights(?:\.(?P<part>[A-Za-z_][A-Za-z0-9_-]*))?|(?P<worlds>num_worlds)"
+                   r"|policy\.(?P<field>[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, a weights placeholder
+    with no weights - or no such part - to fill it, "{num_worlds}" where no worlds are built, or a policy field no policy
+    declares."""
+
+
+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 = None, worlds: int | None = None, policy: Any = None) -> Any:
+    """`value` with its config files read (from `base_dir`) and its forms filled: a policy's from `weights` - the
+    weights directory, or {part: directory} for named parts, or None for a policy without weights - a benchmark's from
+    `worlds`, how many worlds this eval builds, and `policy`, what the evaluated policy declares ({field: value}, or an
+    object with them; None where none is evaluated, each field None). A string that is one form alone becomes its value
+    as it is; one form among other text, its value as text."""
+    forms = {"base_dir": base_dir, "weights": weights, "worlds": worlds, "policy": policy}
+    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, **forms)
+    if isinstance(value, dict):
+        return {k: expand(v, **forms) for k, v in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [expand(v, **forms) for v in value]
+    if isinstance(value, str):
+        alone = FORMS.fullmatch(value)
+        if alone:
+            return _filled(alone, weights, worlds, policy)
+        return FORMS.sub(lambda m: str(_filled(m, weights, worlds, policy)), value)
+    return value
+
+
+def _filled(form: re.Match, weights: Any, worlds: int | None, policy: Any) -> Any:
+    if form.group("worlds"):
+        if worlds is None:
+            raise ConstructError("{num_worlds} is how many worlds this eval builds, and none is handed: a benchmark of one "
+                                 "world an instance takes none")
+        return worlds
+    field = form.group("field")
+    if field is not None:
+        if field not in POLICY_FIELDS:
+            raise ConstructError(f"{{policy.{field}}}: a policy declares {', '.join(POLICY_FIELDS)}")
+        if policy is None:
+            return None
+        return policy.get(field) if isinstance(policy, dict) else getattr(policy, field, None)
+    return _weights_of(form.group("part"), weights)
+
+
+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 = None, worlds: int | None = None,
+          policy: Any = None, params: dict | None = None) -> Any:
+    """The instance `constructor` (a PolicyConstructor) makes of `cls`: `cls.<make>(*args, **kwargs)`, the function
+    make="package.module:function" names called so, or `cls(...)` - its arguments filled (expand), and `params`, what
+    an eval set of the constructor's other arguments (--param benchmark.NAME=VALUE), laid over them. A keyword argument
+    that is "{policy.<field>}" alone is left out while that field is None - no policy evaluated, at a registration
+    check, or one that declares none - so the constructor's own default holds, as a benchmark's own code did with what
+    @seq.setup was handed before."""
+    forms = {"base_dir": base_dir, "weights": weights, "worlds": worlds, "policy": policy}
+    args = expand(list(constructor.args), **forms)
+    kwargs = {}
+    for name, value in dict(constructor.kwargs).items():
+        filled = expand(value, **forms)
+        alone = FORMS.fullmatch(value) if isinstance(value, str) else None
+        if filled is None and alone is not None and alone.group("field") is not None:
+            continue
+        kwargs[name] = filled
+    return maker(cls, constructor.make)(*args, **{**kwargs, **(params or {})})
+
+
+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.5.0 → sequence_base-0.5.1}/sequence_base/contract/benchmarks.py

@@ -1,9 +1,10 @@
 """
-Contract 5 (registration half) - a benchmark is the env you already have, run as it is: a short class of yours marks
-three methods - @seq.setup builds this eval's worlds after the machine's snapshot, @seq.reset starts an episode of a task
-at a seed, @seq.step plays one action and says what came of it - and declares its tasks, its seeds and how long an episode
-may run. The platform reads none of its observations or actions: they go to the policy, and come from it, as a robot's
-do. The eval *run* wire types (RolloutResult, EvalReport, ...) live in contract/eval.py.
+Contract 5 (registration half) - a benchmark is the env you already have, run as it is: its class is built by its own
+constructor after the machine's snapshot (init= its arguments, "{num_worlds}" and "{policy.<field>}" filled), a short class
+of yours marks two methods - @seq.reset starts an episode of a task at a seed, @seq.step plays one action and says what
+came of it - and declares its tasks, its seeds and how long an episode may run. The platform reads none of its
+observations or actions: they go to the policy, and come from it, as a robot's do. The eval *run* wire types
+(RolloutResult, EvalReport, ...) live in contract/eval.py.
 
 
 """
@@ -18,7 +19,8 @@ from sequence_base.constants.limits import MAX_ENVS, TASK_DESCRIPTION_MAX
 from sequence_base.contract.accounts import SecretRef
 from sequence_base.contract.deployments import CodeBundle, DeploymentState, InferParam
 from sequence_base.contract.flags import BENCHMARK_BINDABLE, SeqFlags
-from sequence_base.contract.policy import KIND_NAME, ImageSpec, VolumeRef
+from sequence_base.contract.policy import KIND_NAME, ImageSpec, PolicyConstructor, VolumeRef
+from sequence_base.construct import FORMS
 
 __all__ = [
     "ReplaySpec",
@@ -31,6 +33,27 @@ __all__ = [
 TASK_NAME = r"^[A-Za-z0-9][A-Za-z0-9._/:-]{0,127}$"
 
 
+
+SETUP_GONE = ("@seq.setup is gone: a benchmark builds its worlds in its constructor, after the machine's snapshot - "
+              'init= its arguments, "{num_worlds}" how many worlds this eval builds and "{policy.<field>}" what the '
+              "evaluated policy declares; a benchmark registered with @seq.setup is registered again with sequence-ai "
+              "0.51.1 or later (seq deploy)")
+
+
+def _names_worlds(constructor: PolicyConstructor | None) -> bool:
+    """Whether init= hands the constructor "{num_worlds}" anywhere - in a string, at any depth."""
+    def walk(value) -> bool:
+        if isinstance(value, str):
+            return any(m.group("worlds") for m in FORMS.finditer(value))
+        if isinstance(value, dict):
+            return any(walk(v) for v in value.values())
+        if isinstance(value, (list, tuple)):
+            return any(walk(v) for v in value)
+        return False
+
+    return constructor is not None and walk([constructor.args, constructor.kwargs])
+
+
 def _check_tasks(tasks: dict, seeds: list, max_seconds) -> None:
     import re as _re
 
@@ -75,11 +98,11 @@ class ReplaySpec(BaseModel):
 
 
 class BenchmarkSpec(BaseModel):
-    """What `@seq.benchmark(...)` and its marked methods add up to, as an eval runs it. `bindings` names the methods:
-    RESET and STEP always, SETUP when it builds its worlds after the machine's snapshot - which a vectorized env, one
-    stepping `worlds` worlds a call (@seq.concurrent(sizes=[N]) on its step), always does. `max_seconds` is an episode's
-    time on the robot's clock, the same for every task or {task: seconds}; `assets` are versioned scene volumes mounted
-    at /assets; `secrets` by name."""
+    """What `@seq.benchmark(...)` and its marked methods add up to, as an eval runs it. `bindings` names the methods,
+    RESET and STEP; `constructor` the arguments its class is built with after the machine's snapshot (init=) - which a
+    vectorized env, one stepping `worlds` worlds a call (@seq.concurrent(sizes=[N]) on its step), hands how many,
+    "{num_worlds}". `max_seconds` is an episode's time on the robot's clock, the same for every task or {task: seconds};
+    `assets` are versioned scene volumes mounted at /assets; `secrets` by name."""
 
     model_config = ConfigDict(extra="forbid")
 
@@ -89,7 +112,7 @@ class BenchmarkSpec(BaseModel):
     seeds: list[int] = Field(..., description="The seeds an episode starts at; trial k of a task runs seeds[k % len]")
     max_seconds: float | dict[str, float] = Field(..., description="An episode's time limit, or {task: seconds}")
     handler_ref: str
-    bindings: dict[SeqFlags, str] = Field(..., description="SETUP / RESET / STEP -> method name")
+    bindings: dict[SeqFlags, str] = Field(..., description="RESET / STEP -> method name")
 
 
     worlds: int | None = Field(default=None, ge=1, le=MAX_ENVS)
@@ -106,6 +129,10 @@ class BenchmarkSpec(BaseModel):
 
     engine: str | None = Field(default=None, pattern=KIND_NAME)
 
+
+
+    constructor: PolicyConstructor | None = None
+
     @model_validator(mode="after")
     def _tasks(self) -> "BenchmarkSpec":
         _check_tasks(self.tasks, self.seeds, self.max_seconds)
@@ -113,15 +140,18 @@ class BenchmarkSpec(BaseModel):
 
     @model_validator(mode="after")
     def _bindings(self) -> "BenchmarkSpec":
+        if SeqFlags.SETUP in self.bindings:
+            raise ValueError(SETUP_GONE)
         bad = set(self.bindings) - set(BENCHMARK_BINDABLE)
         if bad:
             names = ", ".join(sorted(f.name or str(f.value) for f in bad))
-            raise ValueError(f"a benchmark marks @seq.setup, @seq.reset and @seq.step only; got {names}")
+            raise ValueError(f"a benchmark marks @seq.reset and @seq.step only; got {names}")
         missing = [f.name for f in (SeqFlags.RESET, SeqFlags.STEP) if f not in self.bindings]
         if missing:
             raise ValueError(f"a benchmark marks @seq.reset and @seq.step; {', '.join(missing).lower()} is missing")
-        if self.worlds is not None and SeqFlags.SETUP not in self.bindings:
-            raise ValueError("a vectorized benchmark (@seq.concurrent on its step) builds its worlds in @seq.setup")
+        if self.worlds is not None and not _names_worlds(self.constructor):
+            raise ValueError("a vectorized benchmark (@seq.concurrent on its step) builds its worlds in its "
+                             'constructor, handed how many by init= - init={"worlds": "{num_worlds}"}')
         return self
 
     @model_validator(mode="after")
@@ -132,7 +162,7 @@ class BenchmarkSpec(BaseModel):
 
 class BenchmarkRegisterRequest(BaseModel):
     """POST /v1/benchmarks - what `seq benchmark register` sends: the declaration, the code, and the parameters its
-    @seq.setup takes beside worlds and policy (each settable by an eval's --param, with its type)."""
+    constructor takes with a default beside what init= hands it (each settable by an eval's --param, with its type)."""
 
     model_config = ConfigDict(extra="forbid")
 
@@ -172,9 +202,8 @@ class BenchmarkRegisterRequest(BaseModel):
     @model_validator(mode="after")
     def _param_names(self) -> "BenchmarkRegisterRequest":
         for name in self.params or {}:
-            if not name.isidentifier() or name.startswith("_") or name in ("worlds", "policy"):
-                raise ValueError(f"setup parameter {name!r} is not a public Python identifier other than worlds and "
-                                 "policy")
+            if not name.isidentifier() or name.startswith("_"):
+                raise ValueError(f"parameter {name!r} is not a public Python identifier")
         return self
 
     @model_validator(mode="after")

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

@@ -54,6 +54,11 @@ class ConnectRequest(BaseModel):
     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:
@@ -67,6 +72,8 @@ class ConnectRequest(BaseModel):
             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
 
 
@@ -116,6 +123,12 @@ class ConnectResponse(BaseModel):
 
     standby: Standby | None = None
 
+
+
+
+    standby_retry_s: float | None = Field(default=None, gt=0, le=3600,
+                                          description="no standby could be held yet: ask again in this many seconds")
+
     @model_validator(mode="before")
     @classmethod
     def _retired(cls, data: Any) -> Any:

{sequence_base-0.5.0 → sequence_base-0.5.1}/sequence_base/contract/flags.py

@@ -62,7 +62,8 @@ class SeqFlags(IntFlag):
 
 
 
-BENCHMARK_BINDABLE: frozenset[SeqFlags] = frozenset({SeqFlags.SETUP, SeqFlags.RESET, SeqFlags.STEP})
+
+BENCHMARK_BINDABLE: frozenset[SeqFlags] = frozenset({SeqFlags.RESET, SeqFlags.STEP})
 
 
 def seqflags_json_schema(contract_version: str) -> dict:

{sequence_base-0.5.0 → sequence_base-0.5.1}/sequence_base/contract/policy.py

@@ -544,13 +544,15 @@ _MAKE = r"^(?:[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*:)?[A-Za-z_][A-
 
 
 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`: 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).
+    """How the worker builds a policy's, a team's or a benchmark's class (`init=`): its 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`
+    - a policy's at the replica's cold start, the weights on disk, where one deployed before sequence-ai 0.51.1 ran its
+    `@seq.load`; a benchmark's after the machine's snapshot (BenchmarkSpec.constructor). The values are the user's own,
+    as JSON carries them, but for the 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 a policy's `"{weights}"` (the weights directory) or `"{weights.<part>}"` (a named part's), a benchmark's
+    `"{num_worlds}"` (how many worlds this eval builds) or `"{policy.<field>}"` (what the evaluated policy declares).
 
 """
 
@@ -563,6 +565,10 @@ class PolicyConstructor(BaseModel):
     kwargs: dict[str, Any] = Field(default_factory=dict, description="keyword arguments")
 
 
+
+_TEAM_BINDS = frozenset({SeqFlags.LOAD, SeqFlags.PLAN, SeqFlags.SHUTDOWN, SeqFlags.SAMPLE})
+
+
 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
@@ -596,15 +602,15 @@ class PolicyRegistration(BaseModel):
     def _a_team_plans(self) -> "PolicyRegistration":
 
 
+
+
         if self.spec.team is not None:
-            other = sorted(f.name for f in self.bindings if f not in (SeqFlags.LOAD, SeqFlags.PLAN, SeqFlags.SHUTDOWN))
+            other = sorted(f.name for f in self.bindings if f not in _TEAM_BINDS)
             if other:
-                raise ValueError(f"a team answers no act: it binds @seq.load, @seq.plan and @seq.shutdown alone, not "
+                raise ValueError(f"a team answers no act: it binds @seq.plan, @seq.shutdown and @seq.sample alone, not "
                                  f"{', '.join(other)}")
             if SeqFlags.PLAN not in self.bindings or self.plan_every_s is None:
                 raise ValueError("a team plans: it binds one @seq.plan(every_s=...)")
-            if self.constructor is not None:
-                raise ValueError("a team is built as a policy with @seq.load is, not by a constructor")
         return self
 
     @model_validator(mode="after")
@@ -613,7 +619,8 @@ class PolicyRegistration(BaseModel):
             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:
+            if SeqFlags.INFER not in self.bindings and self.spec.team is None:
+
                 raise ValueError("a policy built by its constructor (constructor) names the method that answers an act "
                                  "(an INFER binding)")
         return self

{sequence_base-0.5.0 → sequence_base-0.5.1}/sequence_base/schemas/ActRequest.json

@@ -66,5 +66,5 @@
   ],
   "title": "ActRequest",
   "type": "object",
-  "x-contract-version": "0.5.32"
+  "x-contract-version": "0.5.33"
 }

{sequence_base-0.5.0 → sequence_base-0.5.1}/sequence_base/schemas/ActResponse.json

@@ -75,5 +75,5 @@
   ],
   "title": "ActResponse",
   "type": "object",
-  "x-contract-version": "0.5.32"
+  "x-contract-version": "0.5.33"
 }

{sequence_base-0.5.0 → sequence_base-0.5.1}/sequence_base/schemas/ActionChunk.json

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

{sequence_base-0.5.0 → sequence_base-0.5.1}/sequence_base/schemas/ActionContract.json

@@ -96,5 +96,5 @@
   ],
   "title": "ActionContract",
   "type": "object",
-  "x-contract-version": "0.5.32"
+  "x-contract-version": "0.5.33"
 }

{sequence_base-0.5.0 → sequence_base-0.5.1}/sequence_base/schemas/ActionStep.json

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

{sequence_base-0.5.0 → sequence_base-0.5.1}/sequence_base/schemas/AdapterPair.json

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

{sequence_base-0.5.0 → sequence_base-0.5.1}/sequence_base/schemas/AddLocal.json

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

{sequence_base-0.5.0 → sequence_base-0.5.1}/sequence_base/schemas/Autoscaler.json

@@ -36,5 +36,5 @@
   },
   "title": "Autoscaler",
   "type": "object",
-  "x-contract-version": "0.5.32"
+  "x-contract-version": "0.5.33"
 }

{sequence_base-0.5.0 → sequence_base-0.5.1}/sequence_base/schemas/BenchmarkRegisterRequest.json

@@ -561,7 +561,7 @@
     }
   },
   "additionalProperties": false,
-  "description": "POST /v1/benchmarks - what `seq benchmark register` sends: the declaration, the code, and the parameters its\n@seq.setup takes beside worlds and policy (each settable by an eval's --param, with its type).",
+  "description": "POST /v1/benchmarks - what `seq benchmark register` sends: the declaration, the code, and the parameters its\nconstructor takes with a default beside what init= hands it (each settable by an eval's --param, with its type).",
   "properties": {
     "assets": {
       "items": {
@@ -766,5 +766,5 @@
   ],
   "title": "BenchmarkRegisterRequest",
   "type": "object",
-  "x-contract-version": "0.5.32"
+  "x-contract-version": "0.5.33"
 }

{sequence_base-0.5.0 → sequence_base-0.5.1}/sequence_base/schemas/BenchmarkSpec.json

@@ -234,6 +234,41 @@
       "title": "ImageStepUvPip",
       "type": "object"
     },
+    "PolicyConstructor": {
+      "additionalProperties": false,
+      "description": "How the worker builds a policy's, a team's or a benchmark's class (`init=`): its own constructor, or the factory\nit names (`make`: a classmethod of it, e.g. LeRobot's `from_pretrained`, or a module's function,\n\"package.module:function\", whose return is the instance its methods are called on), called with `args` and `kwargs`\n- a policy's at the replica's cold start, the weights on disk, where one deployed before sequence-ai 0.51.1 ran its\n`@seq.load`; a benchmark's after the machine's snapshot (BenchmarkSpec.constructor). The values are the user's own,\nas JSON carries them, but for the forms the worker fills in first (sequence_base.construct.expand): a config file's\ncontents, `{\"$config\": <its path from the class's file>, \"$set\": {<keys laid over it>}}`, YAML or JSON, and in any\nstring a policy's `\"{weights}\"` (the weights directory) or `\"{weights.<part>}\"` (a named part's), a benchmark's\n`\"{num_worlds}\"` (how many worlds this eval builds) or `\"{policy.<field>}\"` (what the evaluated policy declares).",
+      "properties": {
+        "args": {
+          "description": "positional arguments, in order",
+          "items": {},
+          "title": "Args",
+          "type": "array"
+        },
+        "kwargs": {
+          "additionalProperties": true,
+          "description": "keyword arguments",
+          "title": "Kwargs",
+          "type": "object"
+        },
+        "make": {
+          "anyOf": [
+            {
+              "maxLength": 512,
+              "pattern": "^(?:[A-Za-z_][A-Za-z0-9_]*(?:\\.[A-Za-z_][A-Za-z0-9_]*)*:)?[A-Za-z_][A-Za-z0-9_]*$",
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "description": "a classmethod or staticmethod that returns the instance, or a module's function, 'package.module:function' (contract 0.5.27); None: the class",
+          "title": "Make"
+        }
+      },
+      "title": "PolicyConstructor",
+      "type": "object"
+    },
     "Project": {
       "additionalProperties": false,
       "description": "A project's own dependency files, which the image installs from (`seq.Image.from_project`, or a policy that\ndeclares no image and whose project has them): each read from the deploy's code bundle. The platform turns them into\nthe install when the image builds - for Linux and the worker's card, whatever machine the author wrote them on: the\nlock's exact versions, else the declared ones held to the versions the author's machine has (`pins`), the local\npackages the code imports with their own, less `exclude`, then `extra`.",
@@ -400,7 +435,7 @@
       ],
       "title": "SeqFlags",
       "type": "integer",
-      "x-contract-version": "0.5.32",
+      "x-contract-version": "0.5.33",
       "x-flag-names": {
         "ACTION": 1048576,
         "CHECK": 65536,
@@ -472,7 +507,7 @@
     }
   },
   "additionalProperties": false,
-  "description": "What `@seq.benchmark(...)` and its marked methods add up to, as an eval runs it. `bindings` names the methods:\nRESET and STEP always, SETUP when it builds its worlds after the machine's snapshot - which a vectorized env, one\nstepping `worlds` worlds a call (@seq.concurrent(sizes=[N]) on its step), always does. `max_seconds` is an episode's\ntime on the robot's clock, the same for every task or {task: seconds}; `assets` are versioned scene volumes mounted\nat /assets; `secrets` by name.",
+  "description": "What `@seq.benchmark(...)` and its marked methods add up to, as an eval runs it. `bindings` names the methods,\nRESET and STEP; `constructor` the arguments its class is built with after the machine's snapshot (init=) - which a\nvectorized env, one stepping `worlds` worlds a call (@seq.concurrent(sizes=[N]) on its step), hands how many,\n\"{num_worlds}\". `max_seconds` is an episode's time on the robot's clock, the same for every task or {task: seconds};\n`assets` are versioned scene volumes mounted at /assets; `secrets` by name.",
   "properties": {
     "assets": {
       "items": {
@@ -485,7 +520,7 @@
       "additionalProperties": {
         "type": "string"
       },
-      "description": "SETUP / RESET / STEP -> method name",
+      "description": "RESET / STEP -> method name",
       "propertyNames": {
         "enum": [
           "1",
@@ -508,6 +543,17 @@
       "title": "Bindings",
       "type": "object"
     },
+    "constructor": {
+      "anyOf": [
+        {
+          "$ref": "#/$defs/PolicyConstructor"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": null
+    },
     "cpu": {
       "anyOf": [
         {
@@ -656,5 +702,5 @@
   ],
   "title": "BenchmarkSpec",
   "type": "object",
-  "x-contract-version": "0.5.32"
+  "x-contract-version": "0.5.33"
 }

{sequence_base-0.5.0 → sequence_base-0.5.1}/sequence_base/schemas/BenchmarkStatusResponse.json

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

{sequence_base-0.5.0 → sequence_base-0.5.1}/sequence_base/schemas/BootstrapResponse.json

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