Blame for code/case1/runner/art_runner/released.py

"""Bridge that executes the RELEASED Case 1 controller code verbatim (NEW CODE).

The released ROS 2 node /sbel/Desktop/ros_ws/src/path_follower/path_follower/
path_follower.py and its MPC module mpc_wpts.py are imported unchanged from the
image (SHA256 checked against pinned values). Only the rclpy executor layer is replaced (ros_stubs.py).
ControlNode.state_callback, vel_callback, error_state and pub_callback run
unmodified; the DriverInputs message passed to publish() is intercepted.

Two non-numerical adaptations, both verified by parity tests:
1. keras_core.models.load_model is wrapped by a cache that (a) checks the
   SHA256 of the requested released checkpoint, (b) loads it from a
   byte-identical private copy (keras_core opens .keras files with mode
   'r+b', which a non-root container user cannot do on the root-owned
   originals), and (c) returns the same model object for every new
   ControlNode so a fresh node per episode costs no reload.
2. model.predict is wrapped to force verbose=0 (silences the progress bar;
   no numerical effect -- checked bitwise in the parity test).

Raw (pre-rate-limit) controller outputs are read from pub_callback's own
local variables with a sys.settrace hook that only observes the pub_callback
frame (no code is changed or re-implemented).
"""
import hashlib
import importlib.util
import os
import shutil
import sys
import time

import numpy as np

from . import ros_stubs

RELEASED_DIR = '/sbel/Desktop/ros_ws/src/path_follower/path_follower'
RELEASED_SHA256 = {
    'path_follower.py': '1df60ad0cc857d366c48d644ad5c01d05d6b93589b71617b4adf718c3cddf870',
    'mpc_wpts.py': '68b2fac17a53799832715b4c7503d3bbe1762aee7432dbdc853985a8f70c35a8',
}
CHECKPOINT_SHA256 = {
    '/sbel/Desktop/ros_ws/src/nn_models_lib/single_speed_MC_IL_NN.keras':
        '4acd9d199d81bb981f5f6cd43c5a87ba2f994d886aaa50e2a6a8d2e9c0c2305f',
    '/sbel/Desktop/ros_ws/src/nn_models_lib/single_speed_MPC_IL_NN.keras':
        '65118a5c45d9018aef4a6258b1bca23dfe3dde37ff708c6bba61d4b16392bae0',
}
WAYPOINT_DIR = '/sbel/Desktop/waypoints_paths'
# Controller copies shipped with the runner: path relative to runner/ and the
# pinned SHA256 (checked before import). The copy differs from the released mpc_wpts.py only in the horizon N.
RUNNER_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
MPC_N5_FILE = os.path.join(RUNNER_ROOT, 'controllers', 'mpc_wpts_n5.py')
CONTROLLER_COPY_FILES = (MPC_N5_FILE,)
RELEASED_CONTROLLERS = ('mpc', 'nnmpc', 'pid', 'nnhd')
OSQP_FAILURE_TEXT = 'OSQP did not solve the problem!'

_MODULE = None
_MODEL_CACHE = {}
_OSQP_PIN = {'interval': 25, 'patched': False}
# READ-ONLY OSQP diagnostics. Every
# osqp.OSQP.solve() call made by released MPC code (or an MPC-based plug-in) appends one record here; the episode loop
# drains the list after each controller tick and writes mpc_diag.csv.gz. Nothing is passed back into the solver.
_OSQP_DIAG = {'records': []}
OSQP_INFO_FIELDS = ('status', 'status_val', 'status_polish', 'iter', 'rho_updates', 'rho_estimate', 'obj_val',
                    'pri_res', 'dua_res', 'setup_time', 'solve_time', 'update_time', 'polish_time', 'run_time')
OSQP_WALL_FIELDS = ('setup_time', 'solve_time', 'update_time', 'polish_time', 'run_time')  # wall clock (seconds)


def set_osqp_adaptive_rho_interval(n):
    """None = released behaviour (OSQP picks the interval from wall-clock time); int = pinned."""
    _OSQP_PIN['interval'] = n


def osqp_diag_take():
    """Return and clear the OSQP solve records collected since the last call."""
    recs = _OSQP_DIAG['records']
    _OSQP_DIAG['records'] = []
    return recs


def _record_osqp_solve(prob, res):
    """Copy scalar fields of res.info and the problem size into a plain dict. Read-only: it only reads attributes of
    the returned results object, the Python-side setup record and OSQP.dimensions() (two C ints). It never calls
    OSQP._model._get_workspace(), which in osqp 0.6.5 wraps the solver's own C memory in numpy arrays flagged
    OWNDATA (src/extension/include/osqpworkspacepy.h) and is therefore unsafe to call on a live solver.
    Never raises (a diagnostic failure is recorded in 'diag_error' and cannot change an outcome)."""
    try:
        info = getattr(res, 'info', None)
        rec = {k: getattr(info, k, None) for k in OSQP_INFO_FIELDS}
        rec['adaptive_rho_interval_requested'] = getattr(prob, '_tr_adaptive_rho_interval', None)
        rec['setup_max_iter'] = getattr(prob, '_tr_max_iter', None)
        rec['setup_warm_start'] = getattr(prob, '_tr_warm_start', None)
        try:
            n, m = prob._model.dimensions()
            rec['qp_n'], rec['qp_m'] = int(n), int(m)
        except Exception:
            rec['qp_n'] = rec['qp_m'] = None
        rec['diag_error'] = None
    except Exception as e:  # pragma: no cover - defensive
        rec = {'diag_error': f'{type(e).__name__}: {e}'}
    _OSQP_DIAG['records'].append(rec)


def _patch_osqp():
    """Wrap osqp.OSQP.setup so that, if pinned, adaptive_rho_interval=<n> is passed. The released call
    prob.setup(P, q, A, l, u, warm_start=True, max_iter=10000) is otherwise unchanged.
    Also wraps osqp.OSQP.solve READ-ONLY. The wrapper calls the original
    solve with the same arguments, records res.info (status, iterations, rho updates / estimate, wall timings) and the
    problem size, and returns the identical results object. The setup wrapper additionally stores the settings it
    passed (adaptive_rho_interval, max_iter, warm_start) as attributes of the Python OSQP object."""
    import osqp
    if _OSQP_PIN['patched']:
        return
    original_setup = osqp.OSQP.setup
    original_solve = osqp.OSQP.solve

    def setup(self, *args, **kwargs):
        if _OSQP_PIN['interval'] is not None and 'adaptive_rho_interval' not in kwargs:
            kwargs['adaptive_rho_interval'] = _OSQP_PIN['interval']
        self._tr_adaptive_rho_interval = kwargs.get('adaptive_rho_interval')  # None = OSQP automatic (wall clock)
        self._tr_max_iter = kwargs.get('max_iter')
        self._tr_warm_start = kwargs.get('warm_start')
        return original_setup(self, *args, **kwargs)

    def solve(self, *args, **kwargs):
        res = original_solve(self, *args, **kwargs)
        _record_osqp_solve(self, res)
        return res

    setup._tr_original = original_setup
    solve._tr_original = original_solve
    osqp.OSQP.setup = setup
    osqp.OSQP.solve = solve
    _OSQP_PIN['patched'] = True


def sha256_file(path):
    h = hashlib.sha256()
    with open(path, 'rb') as f:
        for chunk in iter(lambda: f.read(1 << 20), b''):
            h.update(chunk)
    return h.hexdigest()


def load_released_module(cache_dir=None):
    """Import the released path_follower.py once per process and return it."""
    global _MODULE
    if _MODULE is not None:
        return _MODULE
    for name, digest in RELEASED_SHA256.items():
        got = sha256_file(os.path.join(RELEASED_DIR, name))
        if got != digest:
            raise RuntimeError(f'released {name} hash mismatch: {got}')
    os.environ['KERAS_BACKEND'] = 'torch'
    ros_stubs.install()
    _patch_osqp()
    import keras_core.models
    cache_dir = cache_dir or os.path.join(os.environ.get('TMPDIR', '/tmp'), f'tr_c1_ckpt_{os.getpid()}')
    os.makedirs(cache_dir, exist_ok=True)
    original_load_model = keras_core.models.load_model

    def cached_load_model(filepath, *args, **kwargs):
        key = os.path.abspath(filepath)
        if key not in _MODEL_CACHE:
            expected = CHECKPOINT_SHA256.get(key)
            if expected is None:
                raise RuntimeError(f'unexpected checkpoint requested: {key}')
            got = sha256_file(key)
            if got != expected:
                raise RuntimeError(f'checkpoint hash mismatch {key}: {got}')
            copy = os.path.join(cache_dir, os.path.basename(key))
            shutil.copyfile(key, copy)
            if sha256_file(copy) != expected:
                raise RuntimeError('checkpoint copy hash mismatch')
            model = original_load_model(copy, *args, **kwargs)
            original_predict = model.predict

            def predict_silent(x, *a, **k):
                k['verbose'] = 0
                return original_predict(x, *a, **k)

            model._tr_original_predict = original_predict
            model.predict = predict_silent
            _MODEL_CACHE[key] = model
        return _MODEL_CACHE[key]

    keras_core.models.load_model = cached_load_model
    spec = importlib.util.spec_from_file_location('path_follower_released',
                                                  os.path.join(RELEASED_DIR, 'path_follower.py'))
    module = importlib.util.module_from_spec(spec)
    sys.modules['path_follower_released'] = module
    spec.loader.exec_module(module)
    keras_core.models.load_model = original_load_model
    solver_file = module.mpc_wpts_solver.__code__.co_filename
    if os.path.realpath(solver_file) != os.path.realpath(os.path.join(RELEASED_DIR, 'mpc_wpts.py')):
        raise RuntimeError(f'mpc_wpts imported from unexpected file {solver_file}')
    module._tr_cached_load_model = cached_load_model
    _MODULE = module
    return module


# ---------------------------------------------------------------------------
# Message construction (exactly what ChROSBodyHandler publishes)
# ---------------------------------------------------------------------------
def make_messages(state, noise=(0.0, 0.0, 0.0)):
    """Build (PoseStamped, TwistStamped) from a physics-server state dict.

    ChROSBodyHandler.cpp:52-85 (image): position = chassis->GetPos() (COG),
    orientation.x/y/z/w = rot[0]/rot[1]/rot[2]/rot[3] (Chrono e0=w,e1,e2,e3),
    twist.linear = GetPos_dt() (absolute frame), twist.angular = GetWvel_loc().
    Optional observation noise (dx, dy, dyaw) is applied to the position and
    as a rotation about the world z axis (q' = qz(dyaw) * q).
    """
    from geometry_msgs.msg import PoseStamped, TwistStamped
    pose = PoseStamped()
    twist = TwistStamped()
    t = state['time']
    sec = int(np.floor(t))
    pose.header.stamp.sec = sec
    pose.header.stamp.nanosec = int(round((t - sec) * 1e9)) % 1000000000
    twist.header.stamp = pose.header.stamp
    e0, e1, e2, e3 = (float(state[k]) for k in ('q_e0', 'q_e1', 'q_e2', 'q_e3'))
    dx, dy, dyaw = (float(v) for v in noise)
    if dyaw != 0.0:
        cw, sw = np.cos(0.5 * dyaw), np.sin(0.5 * dyaw)
        e0, e1, e2, e3 = (cw * e0 - sw * e3, cw * e1 - sw * e2, cw * e2 + sw * e1, cw * e3 + sw * e0)
        e0, e1, e2, e3 = float(e0), float(e1), float(e2), float(e3)
    pose.pose.position.x = float(state['cog_x']) + dx
    pose.pose.position.y = float(state['cog_y']) + dy
    pose.pose.position.z = float(state['cog_z'])
    pose.pose.orientation.x = e0
    pose.pose.orientation.y = e1
    pose.pose.orientation.z = e2
    pose.pose.orientation.w = e3
    twist.twist.linear.x = float(state['vel_x'])
    twist.twist.linear.y = float(state['vel_y'])
    twist.twist.linear.z = float(state['vel_z'])
    twist.twist.angular.x = float(state['wloc_x'])
    twist.twist.angular.y = float(state['wloc_y'])
    twist.twist.angular.z = float(state['wloc_z'])
    return pose, twist


class _FrameCapture:
    """sys.settrace hook capturing the locals of one code object at return."""

    def __init__(self, code):
        self.code = code
        self.locals = None

    def global_trace(self, frame, event, arg):
        if frame.f_code is self.code:
            return self.local_trace
        return None

    def local_trace(self, frame, event, arg):
        if event == 'return':
            self.locals = dict(frame.f_locals)
        return self.local_trace


def _f(v):
    return None if v is None else float(v)


class ReleasedController:
    """One of the four released controllers, run through the released node."""

    kind = 'released'

    def __init__(self, name, module=None, capture_locals=True):
        if name not in RELEASED_CONTROLLERS:
            raise ValueError(f'unknown released controller {name}')
        self.name = name
        self.module = module or load_released_module()
        self.capture_locals = capture_locals
        self.node = None
        self._capture = _FrameCapture(self.module.ControlNode.pub_callback.__code__)

    def reset(self, reference):
        """Construct a FRESH ControlNode (released __init__) for a new episode.

        reference.released_stem is passed as the ref_path parameter, so for a
        released CSV the node loads it itself with np.loadtxt; a generated
        reference overrides node.ref_traj after construction.
        """
        ros_stubs.Node.parameter_overrides = {
            'controller': self.name,
            'ref_path': reference.ref_path_parameter,
            'exp_index': 1,
        }
        node = self.module.ControlNode()
        node.file.close()
        if reference.override_array is not None:
            node.ref_traj = np.array(reference.override_array, dtype=float, copy=True)
        self.node = node
        return node

    def observe(self, pose_msg, twist_msg):
        self.node.state_callback(pose_msg)
        self.node.vel_callback(twist_msg)

    def tick(self):
        node = self.node
        n_before = len(node._published)
        cap = self._capture
        cap.locals = None
        exc = None
        t0 = time.perf_counter()
        if self.capture_locals:
            sys.settrace(cap.global_trace)
        try:
            node.pub_callback()
        except Exception as e:  # classified by the episode loop
            exc = e
        finally:
            if self.capture_locals:
                sys.settrace(None)
        wall = time.perf_counter() - t0
        loc = cap.locals or {}
        published = node._published[n_before:]
        out = {
            'published': len(published) > 0,
            'n_published': len(published),
            'compute_wall_s': wall,
            'exception': exc,
            'e': [float(v) for v in loc['e']] if 'e' in loc else None,
            'e_track': [float(v) for v in loc['e_tracking']] if 'e_tracking' in loc else None,
            'raw_throttle': _f(node.throttle) if 'e' in loc else None,
            'raw_steering': _f(loc.get('steering')),
            'rate_limited': (abs(float(loc['delta_steering'])) > 0.25) if 'delta_steering' in loc else None,
            'ratelimited_steering': _f(node.steering),
            'obs_x': float(node.x), 'obs_y': float(node.y), 'obs_theta': float(node.theta), 'obs_v': float(node.v),
        }
        if published:
            msg = published[-1]
            out['pub_steering'] = float(msg.steering)
            out['pub_throttle'] = float(msg.throttle)
            out['pub_braking'] = float(msg.braking)
        return out


def controller_code_files():
    """Files whose code counts as CONTROLLER code for the outcome classification: the released node and MPC module
    in the image, plus verbatim-derived controller copies shipped with the runner (runner/controllers/, e.g. the
    MPC-N5 variant)."""
    files = {os.path.realpath(os.path.join(RELEASED_DIR, n)) for n in RELEASED_SHA256}
    files |= {os.path.realpath(p) for p in CONTROLLER_COPY_FILES}
    return files


def classify_controller_exception(exc):
    """Return (category, text). category in {'controller_solver_failure', 'controller_exception', 'infrastructure'}.

    Anchors are frames in controller code (released files, controller copies) or a plug-in frame that hands control
    to a released law (_PLUGIN_LAW_ANCHORS: plugin:wrapped_released and plugin:mpc_n5). Rules, deepest frame last:
      * OSQP 'did not solve' ValueError raised in controller code            -> controller_solver_failure
      * no anchor on the stack                                               -> infrastructure (runner / plug-in bug)
      * deepest frame in runner code (art_runner/), incl. the anchor itself  -> infrastructure
      * a runner frame between the last anchor and the deepest frame that is not a transparent wrapper
                                                                             -> infrastructure
      * otherwise (deepest frame in keras / torch / osqp / numpy / scipy / other libraries or controller code)
                                                                             -> controller_exception
    For the four released controllers the anchors are exactly the released-file frames, so their classification is
    unchanged by the plug-in anchors."""
    import traceback
    tb = traceback.extract_tb(exc.__traceback__)
    files = [os.path.realpath(fr.filename) for fr in tb]
    ctrl = controller_code_files()
    own = os.path.realpath(os.path.dirname(os.path.abspath(__file__)))
    text = ''.join(traceback.format_exception(type(exc), exc, exc.__traceback__))[-4000:]

    def is_runner(f):
        return f.startswith(own + os.sep) and f not in ctrl

    if isinstance(exc, ValueError) and str(exc) == OSQP_FAILURE_TEXT and files and files[-1] in ctrl:
        return 'controller_solver_failure', text
    anchors = [i for i, (f, fr) in enumerate(zip(files, tb))
               if f in ctrl or (is_runner(f) and (os.path.basename(f), fr.name) in _PLUGIN_LAW_ANCHORS)]
    if anchors:
        if is_runner(files[-1]):
            return 'infrastructure', text  # the exception was raised in runner code (stubs, wrappers, plug-in code)
        # The numerically transparent wrappers below sit between released code and keras/OSQP; an exception raised
        # INSIDE those libraries is not labelled infrastructure only because the wrapper frame is on the stack.
        tail = [(f, fr.name) for f, fr in zip(files[anchors[-1] + 1:], tb[anchors[-1] + 1:])]
        if any(is_runner(f) and (os.path.basename(f), n) not in _TRANSPARENT_WRAPPERS for f, n in tail):
            return 'infrastructure', text  # bug in the runner's stubs/wrappers called by controller code
        # raised while executing controller code (incl. third-party libraries it calls)
        return 'controller_exception', text
    return 'infrastructure', text


# Runner frames that only forward a call from controller code to keras_core / OSQP (see module docstring);
# ('released.py', 'solve') = the read-only OSQP diagnostics wrapper.
_TRANSPARENT_WRAPPERS = {('released.py', 'predict_silent'), ('released.py', 'setup'), ('released.py', 'solve')}
# Plug-in frames that call a released controller law directly. They play the
# role of the released pub_callback branch for plugin:wrapped_released (incl. the scaled NN-HD variants
# and the scaled MPC / PID variants) and plugin:mpc_n5.
_PLUGIN_LAW_ANCHORS = {('plugins.py', '_call_released_law'), ('plugins.py', '_call_mpc_n5_law')}