| """Closed, actor-safe action-validation data; no simulator or model imports. |
| |
| An issue describes only a deterministic input rejection. It must never carry |
| native exceptions, task state, response text, credentials or unknown outcomes. |
| The service, policy and trusted driver may share this DTO without sharing |
| control authority. Raising ``ActionRejected`` promises that the rejected |
| vector itself has not executed; previously acknowledged prefix controls remain |
| real and are accounted for separately by the driver. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import math |
| from dataclasses import dataclass |
| from numbers import Real |
| from typing import TYPE_CHECKING, ClassVar |
|
|
| if TYPE_CHECKING: |
| from benchkit.contracts import ActionSpec |
|
|
|
|
| @dataclass(frozen=True) |
| class ValidationIssue: |
| """Bounded public explanation of an invalid input, never raw error text. |
| |
| ``action_index`` is an optional zero-based component index within the named |
| field. ``limit`` is a single violated/required bound, not a hidden-state |
| value or an arbitrary container. Nonfinite or wrong-type input values are |
| represented by ``actual=None`` rather than copied into the feedback. |
| """ |
|
|
| code: str |
| field: str = "action" |
| actual: int | float | None = None |
| limit: int | float | None = None |
| action_index: int | None = None |
|
|
| CODES: ClassVar[frozenset[str]] = frozenset({ |
| "invalid_json", "unexpected_fields", "invalid_type", "invalid_length", |
| "non_finite", "out_of_bounds", "quaternion_not_unit", |
| "translation_limit", "rotation_limit", "gripper_binary_required", |
| "invalid_stop", "invalid_action", |
| }) |
| FIELDS: ClassVar[frozenset[str]] = frozenset({ |
| "action", "response", "steps", "memory", "note", "safety_stop", |
| "left", "right", "left.pose", "right.pose", |
| "left.opening", "right.opening", "left.translation_m", |
| "right.translation_m", "left.rotation_rad", "right.rotation_rad", |
| "left.quaternion_norm", "right.quaternion_norm", |
| }) |
| MAX_ACTION_INDEX: ClassVar[int] = 2**31 - 1 |
| KEYS: ClassVar[frozenset[str]] = frozenset({ |
| "code", "field", "actual", "limit", "action_index", |
| }) |
|
|
| def __post_init__(self) -> None: |
| if type(self.code) is not str or self.code not in self.CODES: |
| raise ValueError("unknown validation issue code") |
| if type(self.field) is not str or self.field not in self.FIELDS: |
| raise ValueError("unsupported validation issue field") |
| for name in ("actual", "limit"): |
| value = getattr(self, name) |
| if value is None: |
| continue |
| if type(value) not in (int, float): |
| raise ValueError("validation issue values must be finite numbers or null") |
| try: |
| finite = math.isfinite(value) |
| except OverflowError: |
| finite = False |
| if not finite: |
| raise ValueError("validation issue values must be finite numbers or null") |
| if self.action_index is not None and ( |
| type(self.action_index) is not int |
| or not 0 <= self.action_index <= self.MAX_ACTION_INDEX |
| ): |
| raise ValueError("validation issue component index is invalid") |
|
|
| def to_dict(self) -> dict: |
| return {"code": self.code, "field": self.field, "actual": self.actual, |
| "limit": self.limit, "action_index": self.action_index} |
|
|
| @classmethod |
| def from_dict(cls, value: dict) -> "ValidationIssue": |
| if type(value) is not dict or "code" not in value or set(value) - cls.KEYS: |
| raise ValueError("validation issue must contain only supported fields") |
| return cls(**value) |
|
|
|
|
| def validate_action_vector(spec: "ActionSpec", values) -> tuple[float, ...]: |
| """Validate the generic ActionSpec contract without executing any control. |
| |
| Only known input shape/type/finite/bound failures become typed rejections. |
| No broad exception handler reclassifies infrastructure or adapter failures. |
| Semantic validators such as quaternion checks remain benchmark-owned. |
| """ |
| |
| from benchkit.errors import ActionRejected |
|
|
| if not isinstance(values, (list, tuple)): |
| raise ActionRejected(ValidationIssue("invalid_type")) |
| if len(values) != spec.size: |
| raise ActionRejected(ValidationIssue("invalid_length", actual=len(values), limit=spec.size)) |
| normalized = [] |
| for index, value in enumerate(values): |
| if isinstance(value, bool) or not isinstance(value, Real): |
| raise ActionRejected(ValidationIssue("invalid_type", action_index=index)) |
| try: |
| number = float(value) |
| except OverflowError: |
| raise ActionRejected(ValidationIssue("non_finite", action_index=index)) from None |
| if not math.isfinite(number): |
| raise ActionRejected(ValidationIssue("non_finite", action_index=index)) |
| if spec.low is not None and spec.high is not None: |
| if number < spec.low[index]: |
| raise ActionRejected(ValidationIssue("out_of_bounds", actual=number, |
| limit=spec.low[index], action_index=index)) |
| if number > spec.high[index]: |
| raise ActionRejected(ValidationIssue("out_of_bounds", actual=number, |
| limit=spec.high[index], action_index=index)) |
| normalized.append(number) |
| return tuple(normalized) |
|
|
