docs: def send_commands(self, commands, timeout=1.0,
                        max_retries=1, eor=('\n', '\n- ')):
          """ Send a sequence of commands to the drive and collect output.
  
          Takes a sequence of many commands and executes them one by one
          till either all are executed or one runs out of retries
          (`max_retries`). Retries are optionally performed if a command's
          repsonse indicates that there was an error. Remaining commands
          are not executed. The processed output of the final execution
          (last try or retry) of each command that was actually executed
          is returned.
  
          This function basically feeds commands one by one to
          ``send_command`` and collates the outputs.
  
          Parameters
          ----------
          commands : iterable of str
              Iterable of commands to send to the drive. Each command must
              be an ``str``.
          timeout : float or None, optional
              Optional timeout in seconds to use when reading the
              response. A negative value or ``None`` indicates that the
              an infinite timeout should be used.
          max_retries : int, optional
              Maximum number of retries to do per command in the case of
              errors.
          eor : str or iterable of str, optional
              End Of Resonse. An EOR is either a ``str`` or an iterable
              of ``str`` that denote the possible endings of a response.
              'eor' can be a single EOR, in which case it is used for all
              commands, or it can be an iterable of EOR to use for each
              individual command. For most commands, it should be
              ``('\\n', '\\n- ')``, but for running a program, it should
              be ``'*END\\n'``. The default is ``('\\n', '\\n- ')``.
  
          Returns
          -------
          outputs : list of lists
              ``list`` composed of the processed responses of each command
              in the order that they were done up to and including the
              last command executed. See ``send_command`` for the format
              of processed responses.
  
          See Also
          --------
          send_command : Send a single command.
  
          Examples
          --------
  
          A sequence of commands to energize the motor, move it a bit away
          from the starting position, and then do 4 forward/reverse
          cycles, and de-energize the motor. **DO NOT** try these specific
          movement distances without checking that the motion won't damage
          something (very motor and application specific).
  
          >>> from GeminiMotorDrive.drivers import ASCII_RS232
          >>> ra = ASCII_RS232('/dev/ttyS1')
          >>> ra.send_commands(['DRIVE1', 'D-10000', 'GO']
          ...                  + ['D-10000','GO','D10000','GO']*4
          ...                  + [ 'DRIVE0'])
          [['DRIVE1', 'DRIVE1\\r', 'DRIVE1', None, []],
           ['D-10000', 'D-10000\\r', 'D-10000', None, []],
           ['GO', 'GO\\r', 'GO', None, []],
           ['D-10000', 'D-10000\\r', 'D-10000', None, []],
           ['GO', 'GO\\r', 'GO', None, []],
           ['D10000', 'D10000\\r', 'D10000', None, []],
           ['GO', 'GO\\r', 'GO', None, []],
           ['D-10000', 'D-10000\\r', 'D-10000', None, []],
           ['GO', 'GO\\r', 'GO', None, []],
           ['D10000', 'D10000\\r', 'D10000', None, []],
           ['GO', 'GO\\r', 'GO', None, []],
           ['D-10000', 'D-10000\\r', 'D-10000', None, []],
           ['GO', 'GO\\r', 'GO', None, []],
           ['D10000', 'D10000\\r', 'D10000', None, []],
           ['GO', 'GO\\r', 'GO', None, []],
           ['D-10000', 'D-10000\\r', 'D-10000', None, []],
           ['GO', 'GO\\r', 'GO', None, []],
           ['D10000', 'D10000\\r', 'D10000', None, []],
           ['GO', 'GO\\r', 'GO', None, []],
           ['DRIVE0', 'DRIVE0\\r', 'DRIVE0', None, []]]
  
          """
          # If eor is not a list, make a list of it replicated enough for
          # every command.
          if not isinstance(eor, list):
              eor = [eor]*len(commands)
          # Do every command one by one, collecting the responses and
          # stuffing them in a list. Commands that failed are retried, and
          # we stop if the last retry is exhausted.
          responses = []
          for i, command in enumerate(commands):
              rsp = self.send_command(command, timeout=timeout,
                                      max_retries=max_retries,
                                      eor=eor[i])
              responses.append(rsp)
              if self.command_error(rsp):
                  break
              # Put in a slight pause so the drive has a bit of breathing
              # time between commands.
              time.sleep(0.25)
          return responses