py_canoe.core.measurement.Measurement

def break_measurement_in_offline_mode(self) -> bool:
    """Break the measurement in offline mode. This is typically used to pause the measurement for debugging or analysis purposes. Returns True if the break was applied successfully, False otherwise."""
    try:
        if not self.running:
            logger.warning("Measurement is not running, cannot break")
            return False
        self.com_object.Break()
        logger.info('Measurement break applied in Offline mode')
        return True
    except Exception as e:
        logger.error(f"Error breaking CANoe measurement in offline mode: {e}")
        return False

def process_measurement_event_in_single_step(self) -> bool:
    """Process the next measurement event in single step mode. This is typically used for debugging or analysis purposes. Returns True if the event was processed successfully, False otherwise."""
    try:
        self.com_object.Step()
        logger.info('Processed a measurement event in single step ')
        return True
    except Exception as e:
        logger.error(f"Error processing CANoe measurement event in single step: {e}")
        return False

def reset_measurement_in_offline_mode(self) -> bool:
    """Reset the measurement in offline mode. This is typically used to reset the measurement state for debugging or analysis purposes. Returns True if the reset was applied successfully, False otherwise."""
    try:
        self.com_object.Reset()
        logger.info('Measurement reset applied in Offline mode')
        return True
    except Exception as e:
        logger.error(f"Error resetting CANoe measurement in offline mode: {e}")
        return False

def start(self, timeout=30) -> bool:
    """Start the measurement and wait for it to be running. Returns True if the measurement started successfully, False otherwise."""
    try:
        if self.running:
            logger.warning("Measurement is already running")
            return True
        self.measurement_events.START = False
        self.com_object.Start()
        if self._enable_events:
            status = DoEventsUntil(lambda: self.measurement_events.START, timeout, "CANoe Measurement Start")
        else:
            poll_deadline = time.monotonic() + timeout
            status = False
            while time.monotonic() < poll_deadline:
                if self.com_object.Running:
                    status = True
                    break
                time.sleep(0.1)
        if status:
            logger.info('Measurement Started')
            # Stabilization wait: CAPL on start{} handlers and network interface
            # initialization continue asynchronously after the measurement begins.
            time.sleep(2)
            logger.info('Measurement stabilization complete')
        return status
    except Exception as e:
        logger.error(f"Error starting CANoe measurement: {e}")
        return False

def start_measurement_in_animation_mode(self, animation_delay=100, timeout=30) -> bool:
    """Start the measurement in animation mode with a specified animation delay (in milliseconds) and wait for it to start. Returns True if the measurement started successfully, False otherwise."""
    try:
        if self.running:
            logger.warning("Measurement is already running, cannot animate")
            return False
        self.measurement_events.START = False
        self.animation_delay = animation_delay
        self.com_object.Animate()
        status = DoEventsUntil(lambda: self.measurement_events.START, timeout, "CANoe Measurement Animation Initialization")
        if status:
            logger.info(f'Measurement started in Animation mode with animation delay {animation_delay} ms')
        else:
            logger.error(f"Measurement did not start in Animation mode within {timeout} seconds")
        return status
    except Exception as e:
        logger.error(f"Error starting CANoe measurement in animation mode: {e}")
        return False

def stop(self, timeout=30, post_stop_pump: int = 10) -> bool:
    """Stop the measurement and wait for it to be stopped. Returns True if the measurement stopped successfully, False otherwise."""
    return self.stop_ex(timeout, post_stop_pump=post_stop_pump)

def stop_ex(self, timeout=30, post_stop_pump: int = 10) -> bool:
    """Stop the measurement and wait for it to be stopped. Returns True if the measurement stopped successfully, False otherwise. Optionally specify a timeout (in seconds) for waiting and a post-stop pump duration (in seconds) to drain COM callbacks after stopping."""
    t0 = time.monotonic()
    if not self.running:
        logger.warning("Measurement is already stopped")
        return True
    logger.info("stop_ex: calling Stop()")
    self.measurement_events.STOP = False
    try:
        # IMessageFilter (registered in Application.__init__) handles busy-retry
        # automatically — no manual retry loop needed here.
        self.com_object.Stop()
        elapsed = round(time.monotonic() - t0, 2)
        logger.info(f"stop_ex: Stop() accepted after {elapsed}s")
    except Exception as e:
        elapsed = round(time.monotonic() - t0, 2)
        logger.error(f"stop_ex: Stop() failed after {elapsed}s: {e}")
        return False
    if self._enable_events:
        status = DoEventsUntil(lambda: self.measurement_events.STOP, timeout, "CANoe Measurement Stop")
    else:
        # Poll Running without PumpWaitingMessages — pumping during post-stop
        # report generation triggers Windows' "not responding" dialog.
        poll_deadline = time.monotonic() + timeout
        status = False
        while time.monotonic() < poll_deadline:
            if not self.com_object.Running:
                status = True
                break
            time.sleep(0.1)
    elapsed = round(time.monotonic() - t0, 2)
    if status:
        logger.info(f"stop_ex: Running=False confirmed after {elapsed}s total")
        logger.info('Measurement Stopped')
    else:
        logger.warning(f"stop_ex: Running still True after {elapsed}s — timeout")
    if post_stop_pump > 0:
        logger.info(f"stop_ex: draining COM callbacks for {post_stop_pump}s...")
        for _ in range(post_stop_pump * 10):
            pythoncom.PumpWaitingMessages()
            time.sleep(0.1)
    return status