step.timing.do_until_checkpoint
===============================

.. py:module:: step.timing.do_until_checkpoint


Classes
-------

.. autoapisummary::

   step.timing.do_until_checkpoint.DoUntilCheckpoint


Module Contents
---------------

.. py:class:: DoUntilCheckpoint(checkpoint: float, step)

   Bases: :py:obj:`step.Step`


   Run a step until a mission-relative time checkpoint, then cancel it.

   Starts executing ``step`` immediately and cancels it when the robot's
   global synchronizer clock reaches ``checkpoint`` seconds since mission
   start. If the step finishes before the checkpoint, execution continues
   without waiting. This is useful for time-boxing actions within a timed
   Botball run (e.g. "search for objects, but stop at T=45s no matter what").

   Prerequisites:
       The robot must have a ``synchronizer`` configured. The synchronizer
       clock starts when the mission begins.

   :param checkpoint: The mission-relative deadline (in seconds) at which
                      ``step`` will be cancelled.
   :param step: The step to run. Will be cancelled if still active when the
                checkpoint time is reached.

   Example::

       from raccoon.step.timing import do_until_checkpoint
       from raccoon.step.logic import loop_forever

       # Search for objects until T=45s, then move on
       search = loop_forever(seq([
           scan_for_object(),
           drive_forward(10),
       ]))
       seq([
           do_until_checkpoint(45.0, search),
           drive_to_start(),
       ])


   .. py:attribute:: checkpoint


   .. py:attribute:: step


   .. py:method:: collected_resources() -> frozenset[str]

      Return all resources this step *and its children* require.

      Used by ``validate_no_overlap`` for static conflict detection at
      construction time.  Leaf steps don't need to override this — the
      default delegates to ``required_resources``.  Composite steps
      override to union their children's collected resources.



   .. py:method:: run_step(robot: GenericRobot) -> None
      :async:


      Record the wrapper step, then execute the child until the checkpoint.