flowchart LR
    A["External synthetic config"] --> B["Generate cells"]
    B --> C["Mock Pick approach/pick/retract"]
    C --> D{"Mock grasp confirmed?"}
    D -->|"yes"| E["Mock pallet approach/place/retract"]
    E --> F["Save in-memory progress + journal"]
    F --> G{"More cells?"}
    G -->|"yes"| C
    G -->|"no"| H["DRY_RUN_COMPLETE"]
    D -->|"no"| X["ERROR_RECONCILIATION_REQUIRED"]
    F -->|"pause/restart"| Y["RECONCILIATION_REQUIRED"]

{
  "profile": "SYNTHETIC_PALLETIZER_DRY_RUN",
  "dry_run": true,
  "units": "mm",
  "frame": "SYNTHETIC_USER",
  "rows": 2,
  "columns": 2,
  "pitch_x_mm": 20.0,
  "pitch_y_mm": 25.0,
  "clearance_mm": 30.0,
  "pick_pose": [0.0, -40.0, 10.0, 0.0],
  "pallet_base_pose": [-20.0, 20.0, 10.0, 0.0],
  "envelope_mm": {
    "x": [-100.0, 100.0],
    "y": [-100.0, 100.0],
    "z": [0.0, 120.0],
    "r_deg": [-180.0, 180.0]
  }
}

RobotAdapter = MockRobot
GripperAdapter = MockGripper
ProgressStore = MemoryProgressStore
Physical movement = false

# safe-smoke
from __future__ import annotations

import json
import math
from dataclasses import asdict, dataclass
from enum import Enum
from pathlib import Path
from typing import Protocol


class PalletizerError(RuntimeError):
    pass


class RunStatus(str, Enum):
    READY = "READY"
    PAUSED_RECONCILIATION_REQUIRED = "PAUSED_RECONCILIATION_REQUIRED"
    RECONCILIATION_REQUIRED = "RECONCILIATION_REQUIRED"
    ERROR_RECONCILIATION_REQUIRED = "ERROR_RECONCILIATION_REQUIRED"
    COMPLETE = "COMPLETE"


@dataclass(frozen=True)
class Pose:
    x: float
    y: float
    z: float
    r: float


@dataclass(frozen=True)
class Cell:
    index: int
    row: int
    column: int
    place: Pose
    approach: Pose


@dataclass(frozen=True)
class Config:
    profile: str
    rows: int
    columns: int
    pitch_x: float
    pitch_y: float
    clearance: float
    pick: Pose
    base: Pose
    envelope: dict[str, tuple[float, float]]


@dataclass
class Progress:
    next_index: int
    placed_indices: list[int]
    status: str
    last_error: str | None = None


class RobotAdapter(Protocol):
    def plan(self, kind: str, pose: Pose) -> None: ...
    def stop(self, reason: str) -> None: ...


class GripperAdapter(Protocol):
    def close(self) -> None: ...
    def open(self) -> None: ...
    def stop(self, reason: str) -> None: ...


class ProgressStore(Protocol):
    def load(self) -> Progress | None: ...
    def save(self, progress: Progress) -> None: ...


def _pose(value: object) -> Pose:
    if not isinstance(value, list) or len(value) != 4:
        raise PalletizerError("pose має містити 4 числа")
    if not all(isinstance(item, (int, float)) and math.isfinite(item) for item in value):
        raise PalletizerError("pose має бути скінченною")
    return Pose(*(float(item) for item in value))


def parse_config_text(text: str) -> Config:
    raw = json.loads(text)
    expected = {"profile", "dry_run", "units", "frame", "rows", "columns", "pitch_x_mm", "pitch_y_mm", "clearance_mm", "pick_pose", "pallet_base_pose", "envelope_mm"}
    if not isinstance(raw, dict) or set(raw) != expected:
        raise PalletizerError("неправильна schema config")
    if raw["profile"] != "SYNTHETIC_PALLETIZER_DRY_RUN" or raw["dry_run"] is not True:
        raise PalletizerError("дозволено лише dry-run profile")
    if raw["units"] != "mm" or raw["frame"] != "SYNTHETIC_USER":
        raise PalletizerError("невідомі synthetic units/frame")
    if not isinstance(raw["rows"], int) or not isinstance(raw["columns"], int) or not 1 <= raw["rows"] <= 20 or not 1 <= raw["columns"] <= 20:
        raise PalletizerError("rows/columns поза межею")
    for key in ("pitch_x_mm", "pitch_y_mm", "clearance_mm"):
        if not isinstance(raw[key], (int, float)) or not math.isfinite(raw[key]) or raw[key] <= 0:
            raise PalletizerError(f"{key} має бути додатним")
    axes = {"x", "y", "z", "r_deg"}
    if not isinstance(raw["envelope_mm"], dict) or set(raw["envelope_mm"]) != axes:
        raise PalletizerError("неповний envelope")
    envelope: dict[str, tuple[float, float]] = {}
    for axis, limits in raw["envelope_mm"].items():
        if not isinstance(limits, list) or len(limits) != 2 or limits[0] >= limits[1]:
            raise PalletizerError(f"невалідна межа {axis}")
        envelope[axis] = (float(limits[0]), float(limits[1]))
    return Config(raw["profile"], raw["rows"], raw["columns"], float(raw["pitch_x_mm"]), float(raw["pitch_y_mm"]), float(raw["clearance_mm"]), _pose(raw["pick_pose"]), _pose(raw["pallet_base_pose"]), envelope)


def load_config(path: Path) -> Config:
    return parse_config_text(path.read_text(encoding="utf-8"))


def check_pose(pose: Pose, config: Config) -> None:
    for axis, value in {"x": pose.x, "y": pose.y, "z": pose.z, "r_deg": pose.r}.items():
        low, high = config.envelope[axis]
        if not low <= value <= high:
            raise PalletizerError(f"{axis} поза synthetic envelope")


def above(pose: Pose, clearance: float) -> Pose:
    return Pose(pose.x, pose.y, pose.z + clearance, pose.r)


def generate_cells(config: Config) -> list[Cell]:
    cells: list[Cell] = []
    for row in range(config.rows):
        for column in range(config.columns):
            place = Pose(config.base.x + column * config.pitch_x, config.base.y + row * config.pitch_y, config.base.z, config.base.r)
            approach = above(place, config.clearance)
            check_pose(place, config)
            check_pose(approach, config)
            cells.append(Cell(len(cells), row, column, place, approach))
    if len({(cell.place.x, cell.place.y, cell.place.z, cell.place.r) for cell in cells}) != len(cells):
        raise PalletizerError("duplicate cell pose")
    return cells


class MockRobot:
    def __init__(self, fail_after_plans: int | None = None) -> None:
        self.plans: list[tuple[str, Pose]] = []
        self.stopped = False
        self.fail_after_plans = fail_after_plans

    def plan(self, kind: str, pose: Pose) -> None:
        if self.stopped:
            raise PalletizerError("mock robot stopped")
        if kind not in {"JOINT_PLAN", "LINEAR_PLAN"}:
            raise PalletizerError("невідомий mock plan kind")
        if self.fail_after_plans is not None and len(self.plans) >= self.fail_after_plans:
            self.stop("injected robot planning fault")
            raise PalletizerError("injected robot planning fault")
        self.plans.append((kind, pose))

    def stop(self, reason: str) -> None:
        self.stopped = True


class MockGripper:
    def __init__(self, available_objects: int) -> None:
        self.available_objects = available_objects
        self.holding = False
        self.stopped = False

    def close(self) -> None:
        if self.stopped:
            raise PalletizerError("mock gripper stopped")
        if self.available_objects <= 0:
            self.stop("object not confirmed")
            raise PalletizerError("object not confirmed")
        self.available_objects -= 1
        self.holding = True

    def open(self) -> None:
        if self.stopped or not self.holding:
            raise PalletizerError("release without confirmed object")
        self.holding = False

    def stop(self, reason: str) -> None:
        self.stopped = True
        self.holding = False


class MemoryProgressStore:
    def __init__(self) -> None:
        self.payload: str | None = None

    def load(self) -> Progress | None:
        if self.payload is None:
            return None
        raw = json.loads(self.payload)
        return Progress(raw["next_index"], list(raw["placed_indices"]), raw["status"], raw["last_error"])

    def save(self, progress: Progress) -> None:
        self.payload = json.dumps(asdict(progress), sort_keys=True)


class Palletizer:
    def __init__(self, config: Config, robot: RobotAdapter, gripper: GripperAdapter, store: ProgressStore) -> None:
        self.config = config
        self.cells = generate_cells(config)
        self.robot = robot
        self.gripper = gripper
        self.store = store
        self.journal: list[dict[str, object]] = []
        saved = store.load()
        if saved is None:
            self.progress = Progress(0, [], RunStatus.READY.value)
        elif saved.status == RunStatus.COMPLETE.value:
            self.progress = saved
        else:
            saved.status = RunStatus.RECONCILIATION_REQUIRED.value
            self.progress = saved
            self.store.save(self.progress)

    def reconcile(self, observed_placed: list[int], *, operator_ack: bool) -> None:
        if self.progress.status != RunStatus.RECONCILIATION_REQUIRED.value:
            raise PalletizerError("reconciliation зараз не очікується")
        if not operator_ack or observed_placed != self.progress.placed_indices:
            raise PalletizerError("observed map не збігається або немає ack")
        self.progress.status = RunStatus.READY.value
        self.progress.last_error = None
        self.store.save(self.progress)
        self.journal.append({"event": "RECONCILED", "next_index": self.progress.next_index})

    def _run_cell(self, cell: Cell) -> None:
        pick_approach = above(self.config.pick, self.config.clearance)
        for pose in (pick_approach, self.config.pick, pick_approach, cell.approach, cell.place, cell.approach):
            check_pose(pose, self.config)
        self.robot.plan("JOINT_PLAN", pick_approach)
        self.robot.plan("LINEAR_PLAN", self.config.pick)
        self.gripper.close()
        self.robot.plan("LINEAR_PLAN", pick_approach)
        self.robot.plan("JOINT_PLAN", cell.approach)
        self.robot.plan("LINEAR_PLAN", cell.place)
        self.gripper.open()
        self.robot.plan("LINEAR_PLAN", cell.approach)

    def run(self, *, max_cells: int | None = None) -> Progress:
        if self.progress.status != RunStatus.READY.value:
            raise PalletizerError("run заблоковано до reconciliation")
        completed_now = 0
        while self.progress.next_index < len(self.cells):
            cell = self.cells[self.progress.next_index]
            try:
                self._run_cell(cell)
            except PalletizerError as exc:
                self.robot.stop(str(exc))
                self.gripper.stop(str(exc))
                self.progress.status = RunStatus.ERROR_RECONCILIATION_REQUIRED.value
                self.progress.last_error = str(exc)
                self.store.save(self.progress)
                self.journal.append({"event": "ERROR", "cell": cell.index, "reason": str(exc)})
                raise
            self.progress.placed_indices.append(cell.index)
            self.progress.next_index += 1
            completed_now += 1
            self.journal.append({"event": "MOCK_PLACED", "cell": cell.index})
            self.store.save(self.progress)
            if max_cells is not None and completed_now >= max_cells and self.progress.next_index < len(self.cells):
                self.progress.status = RunStatus.PAUSED_RECONCILIATION_REQUIRED.value
                self.store.save(self.progress)
                return self.progress
        self.progress.status = RunStatus.COMPLETE.value
        self.store.save(self.progress)
        self.journal.append({"event": "DRY_RUN_COMPLETE", "cells": len(self.cells)})
        return self.progress

    def journal_jsonl(self) -> str:
        return "\n".join(json.dumps(event, sort_keys=True) for event in self.journal)


fixture = {
    "profile": "SYNTHETIC_PALLETIZER_DRY_RUN",
    "dry_run": True,
    "units": "mm",
    "frame": "SYNTHETIC_USER",
    "rows": 2,
    "columns": 2,
    "pitch_x_mm": 20.0,
    "pitch_y_mm": 25.0,
    "clearance_mm": 30.0,
    "pick_pose": [0.0, -40.0, 10.0, 0.0],
    "pallet_base_pose": [-20.0, 20.0, 10.0, 0.0],
    "envelope_mm": {"x": [-100.0, 100.0], "y": [-100.0, 100.0], "z": [0.0, 120.0], "r_deg": [-180.0, 180.0]},
}

config = parse_config_text(json.dumps(fixture))
store = MemoryProgressStore()
robot_a = MockRobot()
first = Palletizer(config, robot_a, MockGripper(available_objects=2), store)
paused = first.run(max_cells=2)
assert paused.next_index == 2 and paused.status == RunStatus.PAUSED_RECONCILIATION_REQUIRED.value

robot_b = MockRobot()
second = Palletizer(config, robot_b, MockGripper(available_objects=2), store)
try:
    second.run()
except PalletizerError as exc:
    assert "reconciliation" in str(exc)
else:
    raise AssertionError("auto-resume має бути заборонене")
try:
    second.reconcile([0], operator_ack=True)
except PalletizerError:
    pass
else:
    raise AssertionError("невірна observed map має бути відхилена")
second.reconcile([0, 1], operator_ack=True)
complete = second.run()
assert complete.status == RunStatus.COMPLETE.value and complete.placed_indices == [0, 1, 2, 3]
assert len(robot_a.plans) + len(robot_b.plans) == 24
assert "DRY_RUN_COMPLETE" in second.journal_jsonl()

fault_store = MemoryProgressStore()
fault_robot = MockRobot()
faulty = Palletizer(config, fault_robot, MockGripper(available_objects=0), fault_store)
try:
    faulty.run(max_cells=1)
except PalletizerError as exc:
    assert "not confirmed" in str(exc)
else:
    raise AssertionError("невдале захоплення має зупинити dry-run")
assert fault_robot.stopped and faulty.progress.status == RunStatus.ERROR_RECONCILIATION_REQUIRED.value

print(json.dumps({"result": "PASS", "cells": 4, "planned_poses": 24, "resumed_after_reconciliation": True, "hardware": False}, ensure_ascii=False))

python -m py_compile lab14_palletizer_dry_run.py
python lab14_palletizer_dry_run.py

4 cells × 6 plan poses = 24 mock poses
Physical moves = 0

PAUSED_RECONCILIATION_REQUIRED
    -> process restart
RECONCILIATION_REQUIRED
    -> exact observed map + operator_ack
READY -> remaining dry-run -> COMPLETE

python lab14_palletizer_dry_run.py