sequence-base 0.4.0__tar.gz → 0.4.2__tar.gz

{sequence_base-0.4.0 → sequence_base-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sequence-base
-Version: 0.4.0
+Version: 0.4.2
 Summary: 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
 Requires-Dist: pydantic>=2.0

{sequence_base-0.4.0 → sequence_base-0.4.2}/pyproject.toml

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

@@ -9,11 +9,15 @@ decodes, installs the light core and never imports this.
 """
 from sequence_base.codec.image import (
     DEFAULT_JPEG_QUALITY,
-    MAX_UPLOAD_EDGE,
+    FILTERS,
+    MODES,
     decode,
     decode_depth,
     encode,
     encode_depth,
+    image_size,
+    resize_image,
 )
 
-__all__ = ["encode", "decode", "encode_depth", "decode_depth", "DEFAULT_JPEG_QUALITY", "MAX_UPLOAD_EDGE"]
+__all__ = ["encode", "decode", "encode_depth", "decode_depth", "resize_image", "image_size", "DEFAULT_JPEG_QUALITY",
+           "MODES", "FILTERS"]

sequence_base-0.4.2/sequence_base/codec/image.py

@@ -0,0 +1,210 @@
+"""
+The image codec: one camera frame <-> the base64 string the wire carries.
+
+`encode` (frame -> base64 JPEG) is the SDK's client-side path; `decode` (base64 -> uint8 RGB array)
+is the container/worker's server-side path. They live together so the wire format — JPEG, quality
+95, RGB — is defined once and provable by a round-trip test, and so the SDK and the worker cannot
+drift on what they put on and take off the wire.
+
+Pillow is imported lazily inside each function, never at module scope: a caller who only passes
+pre-encoded strings must not need it installed.
+
+Nothing here fits a frame to a policy behind the caller's back (contract 0.5.2): `encode` sends the frame it is given,
+`resize_image` is the tool the robot calls to fit one the way a camera's contract says the policy was trained, and
+`image_size` reads a frame's width and height from its header - what the worker checks a declared camera against.
+
+
+"""
+from __future__ import annotations
+
+import base64
+import binascii
+import io
+import struct
+from typing import Any
+
+
+
+
+
+
+
+
+DEFAULT_JPEG_QUALITY = 95
+
+def encode(frame: Any, *, quality: int = DEFAULT_JPEG_QUALITY) -> str:
+    """
+    One camera frame to the base64 image that `ImageFrame.data` carries.
+
+    `frame` may be a numpy array, a PIL image, raw `bytes` already encoded, or a `str` already base64
+    — the last two pass through untouched, so a caller with their own pipeline is not forced through
+    this one. Codec is JPEG at `quality`, unconditionally, at the frame's own size: fitting it to a
+    policy is `resize_image`, called by the robot. (Before contract 0.5.2 a frame over 640 px on its
+    long edge was scaled down to it here.)
+    """
+    if isinstance(frame, str):
+        return frame
+    if isinstance(frame, (bytes, bytearray)):
+        return base64.b64encode(bytes(frame)).decode()
+
+    try:
+        from PIL import Image
+    except ImportError as e:
+        raise ImportError(
+            "encoding an array or PIL image needs Pillow: pip install 'sequence-base[codec]'. "
+            "Pass an already-encoded base64 str or bytes to avoid it."
+        ) from e
+
+    img = frame if hasattr(frame, "save") else Image.fromarray(frame)
+    if img.mode != "RGB":
+        img = img.convert("RGB")
+    buf = io.BytesIO()
+    img.save(buf, format="JPEG", quality=quality)
+    return base64.b64encode(buf.getvalue()).decode()
+
+
+def decode(data: str) -> "Any":
+    """
+    base64 JPEG/PNG -> HxWx3 uint8 RGB array — the worker's server-side inverse of `encode`.
+
+    This is what turns `ImageFrame.data` back into pixels for the model. Send JPEG q95: 16x smaller
+    than a JSON int array, ~0.5% action delta. {sequences-models worker handler decode_image}
+
+    Returns a numpy array; numpy is part of the `[codec]` extra alongside Pillow.
+    """
+    import numpy as np
+    from PIL import Image
+
+    raw = base64.b64decode(data, validate=False)
+    return np.asarray(Image.open(io.BytesIO(raw)).convert("RGB"), dtype=np.uint8)
+
+
+
+
+
+
+MODES = ("pad", "stretch")
+FILTERS = ("nearest", "box", "bilinear", "hamming", "bicubic", "lanczos")
+
+
+def _to_image(frame: Any) -> "Any":
+    """A frame as an RGB PIL image: a PIL image, encoded bytes (JPEG / PNG), base64 text (a data: URI too), or an
+    HxWx3 uint8 array (anything Image.fromarray takes)."""
+    from PIL import Image
+
+    if isinstance(frame, str):
+        frame = base64.b64decode(frame.split(",", 1)[1] if frame.startswith("data:") else frame, validate=False)
+    if isinstance(frame, (bytes, bytearray)):
+        img = Image.open(io.BytesIO(bytes(frame)))
+    elif hasattr(frame, "save"):
+        img = frame
+    else:
+        img = Image.fromarray(frame)
+    return img if img.mode == "RGB" else img.convert("RGB")
+
+
+def resize_image(frame: Any, width: int, height: int, *, mode: str, filter: str) -> "Any":
+    """
+    One camera frame fitted to `width` x `height`, as the robot sends it to a camera that reads that size: an RGB PIL
+    image, for `encode` next.
+
+    `mode` "pad" scales it into the box keeping its aspect ratio and pads the rest black, centred - openpi's
+    resize_with_pad exactly (both edges truncated with int()), what the templates' client.py ran; "stretch" scales it
+    to the box. `filter` is the resampling filter, one of FILTERS. Neither has a default: they are how the policy was
+    trained, and a policy's contract names them (Camera.resize, Camera.filter). A frame already that size is returned
+    as it is. `frame` is a PIL image, encoded JPEG / PNG bytes, base64 text, or an HxWx3 uint8 array.
+    """
+    if mode not in MODES:
+        raise ValueError(f"mode must be one of {MODES}, got {mode!r}")
+    if filter not in FILTERS:
+        raise ValueError(f"filter must be one of {FILTERS}, got {filter!r}")
+    if int(width) <= 0 or int(height) <= 0:
+        raise ValueError(f"the size must be positive, got {width}x{height}")
+    from PIL import Image
+
+    img = _to_image(frame)
+    if img.size == (width, height):
+        return img
+    resample = Image.Resampling[filter.upper()]
+    if mode == "stretch":
+        return img.resize((width, height), resample=resample)
+    cur_width, cur_height = img.size
+    ratio = max(cur_width / width, cur_height / height)
+    resized_width, resized_height = int(cur_width / ratio), int(cur_height / ratio)
+    resized = img.resize((resized_width, resized_height), resample=resample)
+    canvas = Image.new(resized.mode, (width, height), 0)
+    canvas.paste(resized, (max(0, int((width - resized_width) / 2)), max(0, int((height - resized_height) / 2))))
+    return canvas
+
+
+def image_size(data: str) -> tuple[int, int]:
+    """
+    (width, height) of the frame `ImageFrame.data` carries - base64 JPEG or PNG, a data: URI's prefix taken off -
+    read from its header alone. ValueError for anything else.
+
+    No Pillow: the SDK checks a frame with it before sending, where Pillow may not be installed, and Pillow refuses a
+    header that declares a huge size (DecompressionBombError), which is then not "not an image" at all. A PNG's size
+    is in its IHDR; a JPEG's in the first start-of-frame segment (SOF0-SOF15, but not C4 / C8 / CC, which are not
+    frames).
+    """
+    text = data.split(",", 1)[1] if isinstance(data, str) and data.startswith("data:") else data
+    try:
+        raw = base64.b64decode(text, validate=False)
+    except (binascii.Error, ValueError, TypeError) as e:
+        raise ValueError("not base64") from e
+    if raw[:8] == b"\x89PNG\r\n\x1a\n" and raw[12:16] == b"IHDR" and len(raw) >= 24:
+        return struct.unpack(">II", raw[16:24])
+    if raw[:2] != b"\xff\xd8":
+        raise ValueError("not a JPEG or PNG image")
+    i = 2
+    while i + 4 <= len(raw):
+        if raw[i] != 0xFF:
+            raise ValueError("a JPEG whose segments do not line up")
+        marker = raw[i + 1]
+        if marker == 0xFF:
+            i += 1
+            continue
+        if marker == 0x01 or 0xD0 <= marker <= 0xD8:
+            i += 2
+            continue
+        if marker in (0xD9, 0xDA):
+            break
+        if 0xC0 <= marker <= 0xCF and marker not in (0xC4, 0xC8, 0xCC) and i + 9 <= len(raw):
+            height, width = struct.unpack(">HH", raw[i + 5:i + 9])
+            return width, height
+        i += 2 + int.from_bytes(raw[i + 2:i + 4], "big")
+    raise ValueError("a JPEG with no frame header")
+
+
+
+_DEPTH_UNITS = {"m": 1000.0, "mm": 1.0}
+
+
+def encode_depth(depth: Any, *, unit: str = "m") -> str:
+    """A depth map -> the base64 16-bit PNG a depth frame (ImageFrame kind="depth") carries: millimetres as uint16, 0
+    where there is no reading (NaN, inf, <= 0), clipped at 65.535 m. `unit` is what the array holds: "m" (float metres,
+    the default) or "mm". Lossless, unlike the JPEG colour frames take — a depth error is a geometry error.
+    
+"""
+    import numpy as np
+    from PIL import Image
+
+    if unit not in _DEPTH_UNITS:
+        raise ValueError(f"unit must be one of {sorted(_DEPTH_UNITS)}, got {unit!r}")
+    arr = np.asarray(depth, dtype=np.float64)
+    if arr.ndim != 2:
+        raise ValueError(f"a depth map is HxW, got shape {arr.shape}")
+    mm = arr * _DEPTH_UNITS[unit]
+    mm = np.where(np.isfinite(mm) & (mm > 0), mm, 0.0)
+    buf = io.BytesIO()
+    Image.fromarray(np.clip(np.rint(mm), 0, 65535).astype(np.uint16)).save(buf, format="PNG")
+    return base64.b64encode(buf.getvalue()).decode()
+
+
+def decode_depth(data: str) -> "Any":
+    """A depth frame's data -> HxW uint16 millimetres (0: no reading) — the worker's inverse of `encode_depth`."""
+    import numpy as np
+    from PIL import Image
+
+    raw = base64.b64decode(data, validate=False)
+    return np.asarray(Image.open(io.BytesIO(raw)), dtype=np.uint16)

{sequence_base-0.4.0 → sequence_base-0.4.2}/sequence_base/constants/version.py

@@ -4,7 +4,8 @@
 
 
 
-CONTRACT_VERSION = "0.5.0"
+CONTRACT_VERSION = "0.5.2"
+
 
 
 

{sequence_base-0.4.0 → sequence_base-0.4.2}/sequence_base/contract/deployments.py

@@ -93,8 +93,14 @@ class Autoscaler(BaseModel):
 class Timeouts(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
-    request: int
-    startup: int
+
+
+
+    request: int = Field(..., ge=1, le=3600)
+
+
+
+    startup: int = Field(..., ge=60, le=18000)
 
 
 class VolumeAttach(BaseModel):

{sequence_base-0.4.0 → sequence_base-0.4.2}/sequence_base/contract/io.py

@@ -7,11 +7,15 @@ Declaring one is optional since contract 0.4.14: a deployment that declares none
 handed to the robot at connect.
 """
 from sequence_base.presets.robot_arm import (
+    PAYLOAD_HINT,
     PROPRIO_FIELDS,
     ActionContract,
     Camera,
     Embodiment,
     ObservationContract,
+    fit_hint,
+    frame_size_problem,
 )
 
-__all__ = ["ActionContract", "PROPRIO_FIELDS", "Camera", "ObservationContract", "Embodiment"]
+__all__ = ["ActionContract", "PROPRIO_FIELDS", "Camera", "ObservationContract", "Embodiment", "frame_size_problem",
+           "fit_hint", "PAYLOAD_HINT"]

{sequence_base-0.4.0 → sequence_base-0.4.2}/sequence_base/presets/robot_arm.py

@@ -12,6 +12,7 @@ resolving to these same classes.
 """
 from __future__ import annotations
 
+import math
 from enum import Enum
 from typing import Any, Literal
 
@@ -126,8 +127,19 @@ class ActionContract(BaseModel):
 
     on_violation: Literal["clip", "refuse"] | None = None
 
+
+
+
+    binarize: dict[int, float] | None = Field(
+        default=None, description="dimension -> threshold: the client gives the robot 1.0 above it, 0.0 otherwise")
+
     @model_validator(mode="after")
     def _limits_fit(self) -> "ActionContract":
+        for d, threshold in (self.binarize or {}).items():
+            if not 0 <= d < self.action_dim:
+                raise ValueError(f"binarize names dimension {d}; action_dim is {self.action_dim}")
+            if not math.isfinite(threshold):
+                raise ValueError(f"binarize[{d}] is {threshold}, not a finite threshold")
         if self.bounds is not None:
             if len(self.bounds) != self.action_dim:
                 raise ValueError(f"bounds has {len(self.bounds)} [low, high] pairs; action_dim is {self.action_dim}")
@@ -148,8 +160,10 @@ PROPRIO_FIELDS = ("joint_positions", "joint_velocities", "end_effector_pose", "g
 
 
 class Camera(BaseModel):
-    """One camera view a policy reads: the size it expects. Informational at the worker (the policy resizes);
-    the client resizes and letterboxes to it before sending, so the bytes on the wire are what is used."""
+    """One camera view a policy reads: the size its colour frames arrive at. The worker refuses a frame of another size
+    (400 invalid_request naming the view, the size it got and the SDK call that fits it) and never resizes one: the
+    robot fits its frames before sending - with `sequence_ai.resize_image`, or `policy.prepare_image`, which fits a frame
+    the way `resize` and `filter` say the policy was trained."""
 
     model_config = ConfigDict(extra="forbid")
 
@@ -160,6 +174,58 @@ class Camera(BaseModel):
     depth: bool | None = Field(default=None, description="the view also sends a depth frame (ImageFrame kind=depth)")
 
 
+
+
+
+
+    resize: Literal["pad", "stretch"] | None = Field(
+        default=None, description='how a frame is fitted to width x height: "pad" (letterbox) or "stretch"')
+
+
+
+    filter: Literal["nearest", "box", "bilinear", "hamming", "bicubic", "lanczos"] | None = Field(
+        default=None, description="the resampling filter a frame is fitted with (Pillow's names)")
+
+
+
+
+
+
+
+def frame_size_problem(view: str, index: int, got: tuple[int, int] | None, camera: dict[str, Any]) -> str | None:
+    """What is wrong with frame `index` of camera `view` (counted in the order the request carries that view's frames,
+    from 0), read as `got` (width, height; None: not a JPEG or PNG image), against the camera the contract declares;
+    None when it fits."""
+    if got is None:
+        return f"camera {view!r} frame {index} is not a JPEG or PNG image"
+    want = (int(camera["width"]), int(camera["height"]))
+    if tuple(got) == want:
+        return None
+    return f"camera {view!r} frame {index} is {got[0]}x{got[1]}; the policy reads {want[0]}x{want[1]}"
+
+
+def fit_hint(view: str, camera: dict[str, Any], *, more: bool = False) -> str:
+    """The next step for a frame of camera `view` that does not fit: the SDK call that fits it as the contract says
+    the policy was trained, or, when the contract does not say, the call with the two choices left to the caller -
+    never a guess. `more`: other views did not fit either (details.sizes lists them)."""
+    width, height = int(camera["width"]), int(camera["height"])
+    mode, flt = camera.get("resize"), camera.get("filter")
+    if mode and flt:
+        hint = (f'fit each frame on the robot before sending: policy.prepare_image("{view}", frame), or '
+                f'sequence_ai.resize_image(frame, {width}, {height}, mode="{mode}", filter="{flt}")')
+    else:
+        hint = (f"fit each frame on the robot before sending: sequence_ai.resize_image(frame, {width}, {height}, "
+                f"mode=..., filter=...) with the mode and filter the policy was trained with; this deployment does "
+                f"not declare them")
+    return hint + (" (the same for each view in details.sizes)" if more else "")
+
+
+
+
+PAYLOAD_HINT = ("fit each camera frame on the robot before sending (sequence_ai.resize_image, or policy.prepare_image "
+                "for a deployment that declares how): a frame at the size a policy reads is a few kB")
+
+
 class ObservationContract(BaseModel):
     """What a policy reads, declared once: the worker checks every /act against it before inference, the
     client assembles to it. An observation that does not match is refused with what is missing — it is never

{sequence_base-0.4.0 → sequence_base-0.4.2}/sequence_base/schemas/ActRequest.json

@@ -65,5 +65,5 @@
   ],
   "title": "ActRequest",
   "type": "object",
-  "x-contract-version": "0.5.0"
+  "x-contract-version": "0.5.2"
 }

{sequence_base-0.4.0 → sequence_base-0.4.2}/sequence_base/schemas/ActResponse.json

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

{sequence_base-0.4.0 → sequence_base-0.4.2}/sequence_base/schemas/ActionChunk.json

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

{sequence_base-0.4.0 → sequence_base-0.4.2}/sequence_base/schemas/ActionContract.json

@@ -23,6 +23,22 @@
     "action_space": {
       "$ref": "#/$defs/ActionSpace"
     },
+    "binarize": {
+      "anyOf": [
+        {
+          "additionalProperties": {
+            "type": "number"
+          },
+          "type": "object"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": null,
+      "description": "dimension -> threshold: the client gives the robot 1.0 above it, 0.0 otherwise",
+      "title": "Binarize"
+    },
     "bounds": {
       "anyOf": [
         {
@@ -100,5 +116,5 @@
   ],
   "title": "ActionContract",
   "type": "object",
-  "x-contract-version": "0.5.0"
+  "x-contract-version": "0.5.2"
 }

{sequence_base-0.4.0 → sequence_base-0.4.2}/sequence_base/schemas/ActionStep.json

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

{sequence_base-0.4.0 → sequence_base-0.4.2}/sequence_base/schemas/AdapterTransform.json

@@ -38,5 +38,5 @@
   ],
   "title": "AdapterTransform",
   "type": "object",
-  "x-contract-version": "0.5.0"
+  "x-contract-version": "0.5.2"
 }

{sequence_base-0.4.0 → sequence_base-0.4.2}/sequence_base/schemas/AddLocal.json

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

{sequence_base-0.4.0 → sequence_base-0.4.2}/sequence_base/schemas/Autoscaler.json

@@ -69,5 +69,5 @@
   },
   "title": "Autoscaler",
   "type": "object",
-  "x-contract-version": "0.5.0"
+  "x-contract-version": "0.5.2"
 }

{sequence_base-0.4.0 → sequence_base-0.4.2}/sequence_base/schemas/BenchmarkConditionSpec.json

@@ -62,5 +62,5 @@
   ],
   "title": "BenchmarkConditionSpec",
   "type": "object",
-  "x-contract-version": "0.5.0"
+  "x-contract-version": "0.5.2"
 }

{sequence_base-0.4.0 → sequence_base-0.4.2}/sequence_base/schemas/BenchmarkRegisterRequest.json

@@ -11,6 +11,22 @@
         "action_space": {
           "$ref": "#/$defs/ActionSpace"
         },
+        "binarize": {
+          "anyOf": [
+            {
+              "additionalProperties": {
+                "type": "number"
+              },
+              "type": "object"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "description": "dimension -> threshold: the client gives the robot 1.0 above it, 0.0 otherwise",
+          "title": "Binarize"
+        },
         "bounds": {
           "anyOf": [
             {
@@ -849,5 +865,5 @@
   ],
   "title": "BenchmarkRegisterRequest",
   "type": "object",
-  "x-contract-version": "0.5.0"
+  "x-contract-version": "0.5.2"
 }

{sequence_base-0.4.0 → sequence_base-0.4.2}/sequence_base/schemas/BenchmarkSpec.json

@@ -297,7 +297,7 @@
       ],
       "title": "SeqFlags",
       "type": "integer",
-      "x-contract-version": "0.5.0",
+      "x-contract-version": "0.5.2",
       "x-flag-names": {
         "CHECK": 65536,
         "INFER": 16,
@@ -518,5 +518,5 @@
   ],
   "title": "BenchmarkSpec",
   "type": "object",
-  "x-contract-version": "0.5.0"
+  "x-contract-version": "0.5.2"
 }

{sequence_base-0.4.0 → sequence_base-0.4.2}/sequence_base/schemas/BenchmarkStatusResponse.json

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

{sequence_base-0.4.0 → sequence_base-0.4.2}/sequence_base/schemas/BootstrapResponse.json

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

sequence_base-0.4.2/sequence_base/schemas/Camera.json

@@ -0,0 +1,76 @@
+{
+  "additionalProperties": false,
+  "description": "One camera view a policy reads: the size its colour frames arrive at. The worker refuses a frame of another size\n(400 invalid_request naming the view, the size it got and the SDK call that fits it) and never resizes one: the\nrobot fits its frames before sending - with `sequence_ai.resize_image`, or `policy.prepare_image`, which fits a frame\nthe way `resize` and `filter` say the policy was trained.",
+  "properties": {
+    "depth": {
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": null,
+      "description": "the view also sends a depth frame (ImageFrame kind=depth)",
+      "title": "Depth"
+    },
+    "filter": {
+      "anyOf": [
+        {
+          "enum": [
+            "nearest",
+            "box",
+            "bilinear",
+            "hamming",
+            "bicubic",
+            "lanczos"
+          ],
+          "type": "string"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": null,
+      "description": "the resampling filter a frame is fitted with (Pillow's names)",
+      "title": "Filter"
+    },
+    "height": {
+      "exclusiveMinimum": 0,
+      "maximum": 8192,
+      "title": "Height",
+      "type": "integer"
+    },
+    "resize": {
+      "anyOf": [
+        {
+          "enum": [
+            "pad",
+            "stretch"
+          ],
+          "type": "string"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "default": null,
+      "description": "how a frame is fitted to width x height: \"pad\" (letterbox) or \"stretch\"",
+      "title": "Resize"
+    },
+    "width": {
+      "exclusiveMinimum": 0,
+      "maximum": 8192,
+      "title": "Width",
+      "type": "integer"
+    }
+  },
+  "required": [
+    "width",
+    "height"
+  ],
+  "title": "Camera",
+  "type": "object",
+  "x-contract-version": "0.5.2"
+}

{sequence_base-0.4.0 → sequence_base-0.4.2}/sequence_base/schemas/ClampInfo.json

@@ -23,5 +23,5 @@
   ],
   "title": "ClampInfo",
   "type": "object",
-  "x-contract-version": "0.5.0"
+  "x-contract-version": "0.5.2"
 }

{sequence_base-0.4.0 → sequence_base-0.4.2}/sequence_base/schemas/CodeBundle.json

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

{sequence_base-0.4.0 → sequence_base-0.4.2}/sequence_base/schemas/Concurrency.json

@@ -77,5 +77,5 @@
   },
   "title": "Concurrency",
   "type": "object",
-  "x-contract-version": "0.5.0"
+  "x-contract-version": "0.5.2"
 }

{sequence_base-0.4.0 → sequence_base-0.4.2}/sequence_base/schemas/Conditions.json

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