react-manip 0.1.0__py3-none-any.whl

react_manip/evaluation/protocols.py

@@ -0,0 +1,326 @@
+"""Reusable evaluation schedules selected by TaskSpec.evaluation.
+
+Custom protocol factories receive config and return an object with run(context).
+The context supplies the generic runner, task factory and policy factory.
+"""
+from copy import deepcopy
+from dataclasses import dataclass, field
+import importlib
+import time
+from typing import Any, Callable
+
+from react_manip.core.aggregate import aggregate_results
+from react_manip.core.runner import BenchmarkRunner, _call_with_supported_kwargs
+from react_manip.core.timeouts import (
+    USE_DEFAULT_TASK_WALL_TIMEOUT,
+    resolve_task_wall_timeout_sec,
+)
+from .metrics import pass_metrics
+
+
+def _positive(value, name, *, allow_zero=False):
+    if type(value) is not int or value < (0 if allow_zero else 1):
+        raise ValueError(f'{name} must be an integer >= {0 if allow_zero else 1}')
+    return value
+
+
+@dataclass
+class EvaluationContext:
+    spec: Any
+    factory: Callable
+    policy_factory: Callable
+    robot_id: str | None = None
+    seed: int = 0
+    scenario: Any = None
+    groups: int = 1
+    episodes: int | None = None
+    runner: Any = field(default_factory=BenchmarkRunner)
+    runner_options: dict = field(default_factory=dict)
+    on_result: Callable | None = None
+    viewer: Any = None
+
+    def __post_init__(self):
+        from react_manip.core.compatibility import resolve_task_robot
+        self.robot_id = resolve_task_robot(self.spec, self.robot_id)
+
+    def final_view(self, env, step, result):
+        if self.viewer is None:
+            return
+        hz = self.runner_options.get('control_hz') or self.spec.control_hz
+        horizon = self.runner_options.get('horizon_sec') or self.spec.horizon_sec
+        if result.done or step >= max(1, round(hz*horizon)):
+            from react_manip.core.observation import policy_observation
+            self.viewer.observe(env, policy_observation(result.observation, self.spec, env), result.info)
+
+    def emit(self, row):
+        if self.on_result:
+            self.on_result(row)
+
+    def runner_options_for_episode(self, task_deadline: float | None = None) -> dict:
+        """Return runner options without the protocol-only task budget."""
+
+        options = {k: v for k, v in self.runner_options.items()
+                   if k != 'task_wall_timeout_sec'}
+        if task_deadline is not None:
+            remaining = max(1e-6, task_deadline - time.perf_counter())
+            configured = options.get('episode_wall_timeout_sec')
+            if configured is None:
+                configured = getattr(self.runner, 'episode_wall_timeout_sec', None)
+            if configured is None:
+                configured = remaining
+            options['episode_wall_timeout_sec'] = min(float(configured), remaining)
+        return options
+
+
+class IndependentProtocol:
+    def __init__(self, config):
+        self.config = dict(config)
+        _positive(config.get('episodes', 3), 'episodes')
+
+    def run(self, context):
+        if context.groups != 1:
+            raise ValueError('--groups is only supported by grouped protocols')
+        n = context.episodes if context.episodes is not None else self.config.get('episodes', 3)
+        _positive(n, 'episodes')
+        rows = []
+        task_timeout = resolve_task_wall_timeout_sec(
+            context.spec.task_id,
+            context.runner_options.get('task_wall_timeout_sec', USE_DEFAULT_TASK_WALL_TIMEOUT),
+        )
+        task_started = time.perf_counter()
+        task_deadline = None if task_timeout is None else task_started + task_timeout
+        timed_out = False
+        for i in range(n):
+            if task_deadline is not None and time.perf_counter() >= task_deadline:
+                timed_out = True
+                break
+            if context.viewer:
+                context.viewer.begin_episode(context.spec.task_id, f'{context.spec.task_id}_episode_{i:04d}',
+                                             'evaluation', i, context.runner_options.get('control_hz') or context.spec.control_hz)
+            try:
+                result = context.runner.evaluate(
+                    context.spec, context.factory, context.policy_factory(),
+                    robot_id=context.robot_id, seed=context.seed+i,
+                    env_kwargs={'scenario': deepcopy(context.scenario)} if context.scenario is not None else None,
+                    observation_callback=context.viewer.observe if context.viewer else None,
+                    step_callback=context.final_view if context.viewer else None,
+                    **context.runner_options_for_episode(task_deadline))
+            finally:
+                if context.viewer:
+                    context.viewer.end_episode()
+            row = result.to_dict()
+            rows.append(row)
+            context.emit(row)
+            if row.get('wall_clock_timeout'):
+                timed_out = True
+                break
+        return {'protocol': {**self.config, 'episodes': n}, 'episodes': rows,
+                'summary': aggregate_results(rows) if rows else None,
+                'valid': not timed_out and len(rows) == n and not any('error' in row for row in rows),
+                'wall_clock_timeout': timed_out,
+                'timeout_scope': 'task' if timed_out else None,
+                'task_wall_time_sec': time.perf_counter() - task_started,
+                'completed_episodes': len(rows),
+                'skipped_episodes': n - len(rows)}
+
+
+class _EpisodePolicy:
+    """Separate episode initialization from the legacy policy.reset contract."""
+    def __init__(self, policy, phase, index, seed):
+        self.policy, self.phase, self.index, self.seed = policy, phase, index, seed
+        self.policy_id = getattr(policy, 'policy_id', type(policy).__name__)
+        self.requires_geometry_truth = getattr(policy, 'requires_geometry_truth', False)
+
+    def set_action_dim(self, action_dim):
+        if hasattr(self.policy, 'set_action_dim'):
+            self.policy.set_action_dim(action_dim)
+
+    def reset(self, task_spec=None, **kwargs):
+        _call_with_supported_kwargs(self.policy.begin_episode, {
+            'phase': self.phase, 'episode_index': self.index,
+            'seed': self.seed, 'task_spec': task_spec})
+
+    def act(self, observation, info):
+        return _call_with_supported_kwargs(self.policy.act, {'observation': observation, 'info': info})
+
+    def end_episode(self, **feedback):
+        _call_with_supported_kwargs(self.policy.end_episode, {
+            **feedback, 'phase': self.phase, 'episode_index': self.index})
+
+
+class PracticeExamProtocol:
+    def __init__(self, config):
+        self.config = deepcopy(config)
+        self.practice = _positive(config.get('practice_episodes'), 'practice_episodes', allow_zero=True)
+        self.exam = _positive(config.get('exam_episodes'), 'exam_episodes')
+        self.online = config.get('exam_adaptation') == 'online'
+        if config.get('exam_adaptation') not in ('frozen', 'online'):
+            raise ValueError('unsupported exam_adaptation')
+        scoring = config.get('scoring', {})
+        self.score_key = scoring.get('score_key') if self.online else None
+        if self.online:
+            if scoring.get('primary') != 'mean_exam_task_score' or not isinstance(self.score_key, str) or not self.score_key:
+                raise ValueError('online evaluation requires mean_exam_task_score and score_key')
+        elif scoring.get('primary') != 'exam_success_rate' or scoring.get('scale') != 100:
+            raise ValueError('practice_exam requires exam_success_rate scoring with scale=100')
+        self.ks = scoring.get('pass_k', [1])
+        if not isinstance(self.ks, list) or not self.ks or len(set(self.ks)) != len(self.ks):
+            raise ValueError('pass_k must be a nonempty list of distinct integers')
+        pass_metrics([False]*self.exam, self.ks)
+
+    def run(self, context):
+        if context.episodes is not None:
+            raise ValueError('--episodes cannot override task-owned practice/exam counts')
+        _positive(context.groups, 'groups')
+        if context.scenario is not None and context.groups != 1:
+            raise ValueError('a single --scenario requires --groups 1')
+        groups, all_rows = [], []
+        task_timeout = resolve_task_wall_timeout_sec(
+            context.spec.task_id,
+            context.runner_options.get('task_wall_timeout_sec', USE_DEFAULT_TASK_WALL_TIMEOUT),
+        )
+        task_started = time.perf_counter()
+        task_deadline = None if task_timeout is None else task_started + task_timeout
+        timed_out = False
+        for group_index in range(context.groups):
+            if task_deadline is not None and time.perf_counter() >= task_deadline:
+                timed_out = True
+                break
+            # A factory must return a fresh policy, so adaptation never crosses groups.
+            policy = context.policy_factory()
+            required = ('begin_episode', 'end_episode')
+            if not self.online:
+                required += ('get_adaptation_state', 'set_adaptation_state')
+            missing = [name for name in required if not callable(getattr(policy, name, None))]
+            if missing:
+                raise TypeError('practice_exam policy is missing: ' + ', '.join(missing))
+            group_seed = context.seed + group_index
+            # RGB is managed by the evaluator adapter. Native default offscreen
+            # contexts can open GLFW even for state-only/headless evaluation.
+            kwargs = {'seed': group_seed, 'robot_id': context.robot_id,
+                      'has_offscreen_renderer': False, 'use_camera_obs': False}
+            if context.scenario is not None:
+                kwargs['scenario'] = deepcopy(context.scenario)
+            if context.runner_options.get('render'):
+                kwargs.update(has_renderer=True, has_offscreen_renderer=False, use_camera_obs=False)
+            env = _call_with_supported_kwargs(context.factory, kwargs)
+            rows = []
+            try:
+                scenario = getattr(env, 'scenario', None)
+                if scenario is None:
+                    raise ValueError('practice_exam requires an environment exposing a fixed Scenario')
+                digest = scenario.digest
+                scenario_record = deepcopy(scenario.to_dict())
+                if scenario.task_id != context.spec.task_id:
+                    raise ValueError('environment Scenario belongs to a different task')
+                if context.scenario is not None and digest != context.scenario.digest:
+                    raise ValueError('environment did not preserve the requested Scenario')
+                snapshot = None
+                from react_manip.instances.variation import TASKS as VARIED_TASKS, construct_sampled_episode
+                varied = context.spec.task_id in VARIED_TASKS
+                if varied and (self.practice, self.exam) != (10,5):
+                    raise ValueError('Episode variation requires the released 10/5 schedule')
+                for phase, count in (('practice', self.practice), ('exam', self.exam)):
+                    if phase == 'exam' and not self.online:
+                        snapshot = deepcopy(policy.get_adaptation_state())
+                    for index in range(count):
+                        if task_deadline is not None and time.perf_counter() >= task_deadline:
+                            timed_out = True
+                            break
+                        if phase == 'exam' and not self.online:
+                            policy.set_adaptation_state(deepcopy(snapshot))
+                        # Distinct seeds for trial randomness, independent of scene sampling.
+                        episode_seed = group_seed*1000003 + (0 if phase == 'practice' else self.practice) + index
+                        variation = None
+                        if varied:
+                            next_env, variation = construct_sampled_episode(scenario, context.robot_id,
+                                index + (0 if phase == 'practice' else self.practice), episode_seed,
+                                render=bool(context.runner_options.get('render')))
+                            env.close()
+                            env = next_env
+                        expected_digest = env.scenario.digest if varied else digest
+                        session = _EpisodePolicy(policy, phase, index, episode_seed)
+                        def check_scenario(current_env, step, result):
+                            if current_env.scenario.digest != expected_digest:
+                                raise ValueError('Scenario changed within a practice/exam group')
+                            context.final_view(current_env, step, result)
+                        if context.viewer:
+                            context.viewer.begin_episode(context.spec.task_id,
+                                f'{context.spec.task_id}_group_{group_index:04d}_{phase}_{index:04d}',
+                                phase, index, context.runner_options.get('control_hz') or context.spec.control_hz)
+                        try:
+                            result = context.runner.evaluate(
+                                context.spec, context.factory, session, env=env, stop_on_done=True,
+                                robot_id=context.robot_id, seed=None if varied else episode_seed,
+                                observation_callback=context.viewer.observe if context.viewer else None,
+                                step_callback=check_scenario, score_key=self.score_key,
+                                **context.runner_options_for_episode(task_deadline))
+                        finally:
+                            if context.viewer:
+                                context.viewer.end_episode()
+                        if env.scenario.digest != expected_digest:
+                            raise ValueError('Scenario changed within a practice/exam group')
+                        row = {**result.to_dict(), 'group_index': group_index,
+                               'phase': phase, 'episode_index': index}
+                        if varied:
+                            row['episode_variation'] = variation
+                        rows.append(row)
+                        all_rows.append(row)
+                        context.emit(row)
+                        if row.get('wall_clock_timeout'):
+                            timed_out = True
+                            break
+                        if self.online and "error" in row:
+                            raise ValueError(row["error"])
+                    if timed_out:
+                        break
+                if timed_out:
+                    break
+                exam_rows = [row for row in rows if row['phase'] == 'exam']
+                metrics = pass_metrics([row['passed'] for row in exam_rows], self.ks)
+                metrics['exam_scores'] = [row['episode_score'] for row in exam_rows] if self.online else None
+                metrics['score'] = sum(metrics['exam_scores'])/self.exam if self.online else 100*metrics['pass_rate']
+                groups.append({'group_index': group_index, 'seed': group_seed,
+                               'scenario': scenario_record, 'episodes': rows, 'summary': metrics})
+            finally:
+                env.close()
+            if timed_out:
+                break
+        if timed_out:
+            return {
+                'protocol': self.config,
+                'groups': groups,
+                'episodes': all_rows,
+                'summary': None,
+                'valid': False,
+                'wall_clock_timeout': True,
+                'timeout_scope': 'task',
+                'task_wall_time_sec': time.perf_counter() - task_started,
+                'completed_episodes': len(all_rows),
+                'skipped_episodes': context.groups * (self.practice + self.exam) - len(all_rows),
+            }
+        count = len(groups)
+        summary = {'groups': count, 'exam_episodes': count*self.exam,
+                   'pass_count': sum(g['summary']['pass_count'] for g in groups),
+                   'pass_rate': sum(g['summary']['pass_rate'] for g in groups)/count,
+                   'score': sum(g['summary']['score'] for g in groups)/count}
+        for key in ('pass_at_k', 'pass_all_k'):
+            summary[key] = {str(k): sum(g['summary'][key][str(k)] for g in groups)/count for k in self.ks}
+        return {'protocol': self.config, 'groups': groups, 'episodes': all_rows, 'summary': summary,
+                'valid': not any('error' in row for row in all_rows)}
+
+
+def load_protocol(spec):
+    config = dict(spec.evaluation) or {'protocol': 'independent', 'episodes': 3}
+    name = config.get('protocol')
+    if name == 'independent':
+        return IndependentProtocol(config)
+    if name == 'practice_exam':
+        return PracticeExamProtocol(config)
+    if name == 'custom':
+        module, name = config['factory'].split(':', 1)
+        protocol = getattr(importlib.import_module(module), name)(config=config)
+        if not callable(getattr(protocol, 'run', None)):
+            raise TypeError('custom protocol must expose run(context)')
+        return protocol
+    raise ValueError(f'unknown evaluation protocol: {name!r}')

react_manip/evaluation/viewer.py

@@ -0,0 +1,240 @@
+"""Optional evaluator UI. Displays the policy's existing RGB, never steps the env."""
+from pathlib import Path
+import json
+import re
+import numpy as np
+
+
+class SkipEpisode(Exception):
+    """Raised by the interactive viewer when the current episode is skipped."""
+
+
+def compose_policy_images(images):
+    """Main image on the left, up to two wrist views on the right; no overlays."""
+    from PIL import Image
+    if not 1 <= len(images) <= 3:
+        raise ValueError('evaluation viewer requires one to three policy cameras')
+    names = list(images)
+    for name, frame in images.items():
+        if not re.fullmatch(r'[A-Za-z0-9_-]+', name):
+            raise ValueError('invalid policy camera ID')
+        if not isinstance(frame, np.ndarray) or frame.ndim != 3 or frame.shape[2] != 3 or frame.dtype != np.uint8:
+            raise ValueError('policy cameras must provide uint8 HWC RGB')
+    if len(names) == 1:
+        frame = images[names[0]]
+        return frame, {names[0]: (0, 0, frame.shape[1], frame.shape[0])}
+    width, height = 960, 480
+    canvas = np.zeros((height, width, 3), dtype=np.uint8)
+    boxes = [(0, 0, 640, 480), (640, 0, 320, 240), (640, 240, 320, 240)]
+    layout = {}
+    for name, (x, y, w, h) in zip(names, boxes):
+        source = Image.fromarray(images[name])
+        scale = min(w/source.width, h/source.height)
+        source = source.resize((max(1, round(source.width*scale)), max(1, round(source.height*scale))), Image.Resampling.LANCZOS)
+        ox, oy = x + (w-source.width)//2, y + (h-source.height)//2
+        canvas[oy:oy+source.height, ox:ox+source.width] = np.asarray(source)
+        layout[name] = (ox, oy, source.width, source.height)
+    return canvas, layout
+
+
+def check_dependencies(display, video):
+    try:
+        if display:
+            import pygame
+        if video:
+            import imageio.v2
+            import imageio_ffmpeg
+            imageio_ffmpeg.get_ffmpeg_exe()
+    except (ImportError, RuntimeError) as exc:
+        raise ImportError('Install dependencies: python -m pip install -r requirements.txt') from exc
+
+
+class EvaluationViewer:
+    def __init__(self, *, enabled=False, video_dir=None):
+        self.enabled = enabled
+        self.video_dir = Path(video_dir) if video_dir is not None else None
+        self.active = enabled or self.video_dir is not None
+        self.aborted = False
+        self.skipped = False
+        self.paused = False
+        self.debug = False
+        self.writer = None
+        self.camera_writers = {}
+        self.pg = None
+        self.frames = 0
+
+    def __enter__(self):
+        check_dependencies(self.enabled, self.video_dir is not None)
+        if self.video_dir is not None:
+            self.video_dir.mkdir(parents=True, exist_ok=False)
+        if self.enabled:
+            import pygame
+            self.pg = pygame
+            try:
+                pygame.display.init()
+                pygame.font.init()
+                self.screen = pygame.display.set_mode((1280, 720))
+                pygame.display.set_caption('CL-Manip evaluation | policy RGB')
+                self.font = pygame.font.SysFont('Arial', 18)
+                self.clock = pygame.time.Clock()
+            except BaseException:
+                pygame.display.quit()
+                pygame.font.quit()
+                raise
+        return self
+
+    def __exit__(self, *exc):
+        self.end_episode()
+        if self.pg:
+            self.pg.display.quit()
+            self.pg.font.quit()
+
+    def begin_episode(self, task, episode, phase, index, hz):
+        self.end_episode()
+        self.task, self.episode, self.phase = task, episode, phase
+        self.index, self.hz, self.frames = index, hz, 0
+        self.skipped = False
+        self.camera = None
+        self.cameras = ()
+        self.image_shapes = {}
+        self.layout = {}
+        self.instruction_scroll = 0
+        if self.video_dir is not None:
+            import imageio.v2 as imageio
+            # IDs are evaluator records, but never permit paths to escape output.
+            if Path(episode).name != episode or episode in ('.', '..'):
+                raise ValueError('invalid episode ID for video filename')
+            self.writer = imageio.get_writer(str(self.video_dir / (episode + '.mp4')),
+                                            fps=hz, codec='libx264', quality=8,
+                                            macro_block_size=1, ffmpeg_log_level='error')
+
+    def _events(self):
+        for event in self.pg.event.get():
+            if event.type == self.pg.QUIT or (event.type == self.pg.KEYDOWN and event.key == self.pg.K_ESCAPE):
+                self.aborted = True
+                raise RuntimeError('evaluation aborted by viewer; no valid protocol score')
+            if event.type == self.pg.KEYDOWN:
+                if event.key == self.pg.K_s:
+                    self.skipped = True
+                    raise SkipEpisode('episode skipped by viewer (S)')
+                if event.key == self.pg.K_SPACE:
+                    self.paused = not self.paused
+                elif event.key == self.pg.K_DOWN:
+                    self.instruction_scroll += 1
+                elif event.key == self.pg.K_UP:
+                    self.instruction_scroll = max(0, self.instruction_scroll - 1)
+                elif event.key == self.pg.K_TAB:
+                    self.debug = not self.debug
+
+    def _text(self, text, y, color=(230, 230, 230)):
+        # Wrap by rendered width, including long instructions without spaces.
+        line = ''
+        for char in str(text):
+            if char == '\n' or self.font.size(line + char)[0] > 300:
+                self.screen.blit(self.font.render(line, True, color), (970, y))
+                y += 21
+                line = ''
+                if y > 475:
+                    return y
+            if char != '\n':
+                line += char
+        self.screen.blit(self.font.render(line, True, color), (970, y))
+        return y + 24
+
+    def _instruction(self, text, y):
+        lines, line = [], ''
+        for word in str(text).split():
+            candidate = (line + ' ' + word).strip()
+            if line and self.font.size(candidate)[0] > 300:
+                lines.append(line)
+                line = word
+            else:
+                line = candidate
+        if line:
+            lines.append(line)
+        visible = max(1, (480 - y) // 21)
+        self.instruction_scroll = min(self.instruction_scroll, max(0, len(lines) - visible))
+        for line in lines[self.instruction_scroll:self.instruction_scroll + visible]:
+            self.screen.blit(self.font.render(line, True, (230, 230, 230)), (970, y))
+            y += 21
+
+    def observe(self, env, observation, info):
+        images = observation.get('images', {})
+        frame, layout = compose_policy_images(images)
+        ids = tuple(images)
+        shapes = {k: list(v.shape) for k, v in images.items()}
+        if self.cameras and (ids != self.cameras or shapes != self.image_shapes):
+            raise ValueError('policy camera IDs/order/resolution changed during an episode')
+        if not self.cameras:
+            self.cameras, self.image_shapes, self.layout = ids, shapes, layout
+            self.camera = ids[0]
+            if self.writer is not None:
+                import imageio.v2 as imageio
+                for name in ids:
+                    self.camera_writers[name] = imageio.get_writer(
+                        str(self.video_dir / (self.episode + '.' + name + '.mp4')),
+                        fps=self.hz, codec='libx264', quality=8,
+                        macro_block_size=1, ffmpeg_log_level='error')
+        if self.enabled:
+            self._events()
+            while True:
+                self.screen.fill((24, 26, 30))
+                surface = self.pg.surfarray.make_surface(frame.transpose(1, 0, 2))
+                scale = min(960/frame.shape[1], 720/frame.shape[0])
+                size = (round(frame.shape[1]*scale), round(frame.shape[0]*scale))
+                origin = ((960-size[0])//2, (720-size[1])//2)
+                self.screen.blit(self.pg.transform.scale(surface, size), origin)
+                for name, (x, y, _, _) in layout.items():
+                    label = self.font.render(name, True, (255,255,255), (24,26,30))
+                    self.screen.blit(label, (origin[0]+round(x*scale)+4, origin[1]+round(y*scale)+4))
+                y = 12
+                values = [self.task, f'{self.phase} episode {self.index + 1}',
+                          ', '.join(self.cameras), f'Simulation: {float(env.sim.data.time):.2f} s',
+                          'PAUSED' if self.paused else 'RUNNING',
+                          'Space: pause / resume', 'S: skip episode',
+                          'Tab: external debug view', 'Esc: abort evaluation', 'Up/Down: scroll instruction']
+                for key in ('total_score', 'score', 'success_state'):
+                    if key in info:
+                        values.append(f'{key}: {info[key]}')
+                for value in values:
+                    if y > 475:
+                        break
+                    y = self._text(value, y)
+                self._instruction(info.get('language_prompt', ''), y)
+                if self.debug:
+                    debug_frame = env.render_camera('room_overview', width=320, height=240)
+                    surface = self.pg.surfarray.make_surface(debug_frame.transpose(1, 0, 2))
+                    self.screen.blit(surface, (960, 480))
+                    self.screen.blit(self.font.render('DEBUG - not policy input', True, (255, 200, 80)), (970, 480))
+                self.pg.display.flip()
+                if not self.paused:
+                    break
+                self.clock.tick(30)
+                self._events()
+            self.clock.tick(self.hz)
+        if self.writer is not None:
+            self.writer.append_data(frame)
+            for name, writer in self.camera_writers.items():
+                writer.append_data(images[name])
+        self.frames += 1
+
+    def end_episode(self):
+        if self.writer is not None:
+            writer, self.writer = self.writer, None
+            try:
+                writer.close()
+            finally:
+                for camera_writer in self.camera_writers.values():
+                    camera_writer.close()
+                self.camera_writers.clear()
+            (self.video_dir / (self.episode + '.json')).write_text(json.dumps({
+                'task_id': self.task, 'episode_id': self.episode, 'phase': self.phase,
+                'camera': self.camera, 'cameras': list(self.cameras),
+                'image_shapes': self.image_shapes, 'layout_xywh': self.layout,
+                'composite_video': self.episode + '.mp4',
+                'camera_videos': {n: self.episode + '.' + n + '.mp4' for n in self.cameras},
+                'fps': self.hz, 'frames': self.frames,
+                'image_source': 'same-tick policy RGB; composite plus separate views; no debug overlay',
+                'aborted': self.aborted,
+                'skipped': self.skipped,
+            }, indent=2) + '\n')

react_manip/instances/__init__.py

@@ -0,0 +1,6 @@
+"""Versioned, explicit task/episode instances (simulator imports are lazy)."""
+from .records import digest, load_record, save_record, validate_record, validate_pair
+from .public import InstanceBundle, create_instance, open_instance, task_score
+
+__all__ = ['digest', 'load_record', 'save_record', 'validate_record', 'validate_pair',
+           'InstanceBundle', 'create_instance', 'open_instance', 'task_score']