docs: def run(self, start_point=None, stop_before=None, stop_after=None):
          """
          Run the pipeline, optionally specifying start and/or stop points.
  
          :param str start_point: Name of stage at which to begin execution.
          :param str stop_before: Name of stage at which to cease execution;
              exclusive, i.e. this stage is not run
          :param str stop_after: Name of stage at which to cease execution;
              inclusive, i.e. this stage is the last one run
          :raise IllegalPipelineExecutionError: If both inclusive (stop_after)
              and exclusive (stop_before) halting points are provided, or if that
              start stage is the same as or after the stop stage, raise an
              IllegalPipelineExecutionError.
          """
  
          # Start the run with a clean slate of Stage status/label tracking.
          self._reset()
  
          # TODO: validate starting point against checkpoint flags for
          # TODO (cont.): earlier stages if the pipeline defines its stages as a
          # TODO (cont.): sequence (i.e., probably prohibit start point with
          # TODO (cont): nonexistent earlier checkpoint flag(s).)
  
          if stop_before and stop_after:
              raise IllegalPipelineExecutionError(
                      "Cannot specify both inclusive and exclusive stops.")
  
          if stop_before:
              stop = stop_before
              inclusive_stop = False
          elif stop_after:
              stop = stop_after
              inclusive_stop = True
          else:
              stop = None
              inclusive_stop = None
  
          # Ensure that a stage name--if specified--is supported.
          for s in [start_point, stop]:
              if s is None:
                  continue
              name = parse_stage_name(s)
              if name not in self.stage_names:
                  raise UnknownPipelineStageError(name, self)
  
          # Permit order-agnostic pipelines, but warn.
          if self._unordered and (start_point or stop_before or stop_after):
              print("WARNING: Starting and stopping points are nonsense for "
                    "pipeline with unordered stages.")
  
          # TODO: consider context manager based on start/stop points.
  
          # Determine where to start (but perhaps skip further based on
          # checkpoint completions.)
          start_index = self._start_index(start_point)
          stop_index = self._stop_index(stop, inclusive=inclusive_stop)
          assert stop_index <= len(self._stages)
          if start_index >= stop_index:
              raise IllegalPipelineExecutionError(
                      "Cannot start pipeline at or after stopping point")
  
          # TODO: consider storing just stage name rather than entire stage.
          # TODO (cont.): the bad case for whole-Stage is if associated data
          # TODO (cont.): (i.e., one or more args) are large.
          self.skipped.extend(self._stages[:start_index])
  
          # TODO: support both courses of action for non-continuous checkpoints.
          # TODO (cont.): That is, what if there's a stage with a checkpoint
          # TODO (cont.): file downstream of one without it? Naively, we'll
          # TODO (cont.): skip it, but we may want to re-run.
          skip_mode = True
  
          for stage in self._stages[start_index:stop_index]:
  
              # TODO: Note that there's no way to tell whether a non-checkpointed
              # TODO (cont.) Stage has been completed, and thus this seek
              # TODO (cont.) operation will find the first Stage, starting
              # TODO (cont.) the specified start point, either uncheckpointed or
              # TODO (cont.) for which the checkpoint file does not exist.
              # Look for checkpoint file.
              if skip_mode and self.completed_stage(stage):
                  print("Skipping completed checkpoint stage: {}".format(stage))
                  self.skipped.append(stage)
                  continue
  
              # Once we've found where to being execution, ignore checkpoint
              # flags downstream if they exist since there may be dependence
              # between results from different stages.
              skip_mode = False
  
              print("Running stage: {}".format(stage))
  
              stage.run()
              self.executed.append(stage)
              self.checkpoint(stage)
  
          # Add any unused stages to the collection of skips.
          self.skipped.extend(self._stages[stop_index:])
  
          # Where we stopped determines the shutdown mode.
          if stop_index == len(self._stages):
              self.wrapup()
          else:
              self.halt(raise_error=False)