File size: 5,500 Bytes
6aa6c12 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 | """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.
"""
# Lazy import avoids contracts -> validation -> errors -> contracts cycles.
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)
|