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

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "sequence-base"
-version = "0.4.27"
+version = "0.4.28"
 description = "Shared foundation for the Sequences platform — wire contract, correlation, error taxonomy, constants. Used by the robot SDK, gateway, and container harness."
 requires-python = ">=3.10"
 dependencies = ["pydantic>=2.0"]

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

@@ -4,7 +4,8 @@
 
 
 
-CONTRACT_VERSION = "0.5.24"
+CONTRACT_VERSION = "0.5.25"
+
 
 
 

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

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

sequence_base-0.4.28/sequence_base/contract/obs_schedule.py

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

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

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

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

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

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

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

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

@@ -93,5 +93,5 @@
   ],
   "title": "ActRequest",
   "type": "object",
-  "x-contract-version": "0.5.24"
+  "x-contract-version": "0.5.25"
 }

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

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

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

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

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

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

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

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

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

@@ -47,5 +47,5 @@
   },
   "title": "Actions",
   "type": "object",
-  "x-contract-version": "0.5.24"
+  "x-contract-version": "0.5.25"
 }

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

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

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

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

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

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

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

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

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

@@ -1077,5 +1077,5 @@
   ],
   "title": "BenchmarkRegisterRequest",
   "type": "object",
-  "x-contract-version": "0.5.24"
+  "x-contract-version": "0.5.25"
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{sequence_base-0.4.27 → sequence_base-0.4.28}/sequence_base/schemas/ConnectResponse.json

@@ -568,5 +568,5 @@
   ],
   "title": "ConnectResponse",
   "type": "object",
-  "x-contract-version": "0.5.24"
+  "x-contract-version": "0.5.25"
 }

{sequence_base-0.4.27 → sequence_base-0.4.28}/sequence_base/schemas/DeploymentAccepted.json

@@ -18,5 +18,5 @@
   ],
   "title": "DeploymentAccepted",
   "type": "object",
-  "x-contract-version": "0.5.24"
+  "x-contract-version": "0.5.25"
 }

{sequence_base-0.4.27 → sequence_base-0.4.28}/sequence_base/schemas/DeploymentPolicy.json

@@ -739,38 +739,6 @@
       ],
       "default": null
     },
-    "own_actions": {
-      "anyOf": [
-        {
-          "enum": [
-            "one",
-            "steps"
-          ],
-          "type": "string"
-        },
-        {
-          "type": "null"
-        }
-      ],
-      "default": null,
-      "title": "Own Actions"
-    },
-    "own_observations": {
-      "anyOf": [
-        {
-          "enum": [
-            "latest",
-            "since_last_act"
-          ],
-          "type": "string"
-        },
-        {
-          "type": "null"
-        }
-      ],
-      "default": null,
-      "title": "Own Observations"
-    },
     "params": {
       "anyOf": [
         {
@@ -829,5 +797,5 @@
   ],
   "title": "DeploymentPolicy",
   "type": "object",
-  "x-contract-version": "0.5.24"
+  "x-contract-version": "0.5.25"
 }

{sequence_base-0.4.27 → sequence_base-0.4.28}/sequence_base/schemas/DeploymentRequest.json

@@ -608,38 +608,6 @@
           ],
           "default": null
         },
-        "own_actions": {
-          "anyOf": [
-            {
-              "enum": [
-                "one",
-                "steps"
-              ],
-              "type": "string"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "default": null,
-          "title": "Own Actions"
-        },
-        "own_observations": {
-          "anyOf": [
-            {
-              "enum": [
-                "latest",
-                "since_last_act"
-              ],
-              "type": "string"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "default": null,
-          "title": "Own Observations"
-        },
         "params": {
           "anyOf": [
             {
@@ -1610,5 +1578,5 @@
   ],
   "title": "DeploymentRequest",
   "type": "object",
-  "x-contract-version": "0.5.24"
+  "x-contract-version": "0.5.25"
 }

{sequence_base-0.4.27 → sequence_base-0.4.28}/sequence_base/schemas/DeploymentStatusResponse.json

@@ -58,5 +58,5 @@
   ],
   "title": "DeploymentStatusResponse",
   "type": "object",
-  "x-contract-version": "0.5.24"
+  "x-contract-version": "0.5.25"
 }

{sequence_base-0.4.27 → sequence_base-0.4.28}/sequence_base/schemas/Embodiment.json

@@ -285,5 +285,5 @@
   ],
   "title": "Embodiment",
   "type": "object",
-  "x-contract-version": "0.5.24"
+  "x-contract-version": "0.5.25"
 }