docs: def timestamp(self, message="", checkpoint=None,
                    finished=False, raise_error=True):
          """
          Print message, time, and time elapsed, perhaps creating checkpoint.
  
          This prints your given message, along with the current time, and time
          elapsed since the previous timestamp() call.  If you specify a
          HEADING by beginning the message with "###", it surrounds the message
          with newlines for easier readability in the log file. If a checkpoint
          is designated, an empty file is created corresponding to the name
          given. Depending on how this manager's been configured, the value of
          the checkpoint, and whether this timestamp indicates initiation or
          completion of a group of pipeline steps, this call may stop the
          pipeline's execution.
  
          :param str message: Message to timestamp.
          :param str checkpoint: Name of checkpoint; this tends to be something
              that reflects the processing logic about to be or having just been
              completed. Provision of an argument to this parameter means that
              a checkpoint file will be created, facilitating arbitrary starting
              and stopping point for the pipeline as desired.
          :param bool finished: Whether this call represents the completion of a
              conceptual unit of a pipeline's processing
          :param raise_error: Whether to raise exception if
              checkpoint or current state indicates that a halt should occur.
          """
  
          # Halt if the manager's state has been set such that this call
          # should halt the pipeline.
          if self.halt_on_next:
              self.halt(checkpoint, finished, raise_error=raise_error)
  
          # Determine action to take with respect to halting if needed.
          if checkpoint:
              if finished:
                  # Write the file.
                  self._checkpoint(checkpoint)
                  self.prev_checkpoint = checkpoint
                  self.curr_checkpoint = None
              else:
                  self.prev_checkpoint = self.curr_checkpoint
                  self.curr_checkpoint = checkpoint
                  self._checkpoint(self.prev_checkpoint)
              # Handle the two halting conditions.
              if (finished and checkpoint == self.stop_after) or (not finished and checkpoint == self.stop_before):
                  self.halt(checkpoint, finished, raise_error=raise_error)
              # Determine if we've started executing.
              elif checkpoint == self.start_point:
                  self._active = True
              # If this is a prospective checkpoint, set the current checkpoint
              # accordingly and whether we should halt the pipeline on the
              # next timestamp call.
              if not finished and checkpoint == self.stop_after:
                  self.halt_on_next = True
  
          elapsed = self.time_elapsed(self.last_timestamp)
          t = time.strftime("%m-%d %H:%M:%S")
          if checkpoint is None:
              msg = "{m} ({t}) elapsed: {delta_t} _TIME_".\
                      format(m=message, t=t, delta_t=elapsed)
          else:
              msg = "{m} ({t}) ({status} {stage}) elapsed: {delta_t} _TIME_".\
                  format(m=message, t=t,
                         status="finished" if finished else "starting",
                         stage=checkpoint, delta_t=elapsed)
          if re.match("^###", message):
              msg = "\n{}\n".format(msg)
          print(msg)
          self.last_timestamp = time.time()