code: def get_sequence_time(cycles, unit_converter=None, eres=None):
      
      # If we are doing unit conversion, then that is equivalent to motor
      # units but with eres equal to one.
      if unit_converter is not None:
          eres = 1
      # Starting with 0 time, steadily add the time of each movement.
      tme = 0.0
      # Go through each cycle and collect times.
      for cycle in cycles:
          # Add all the wait times.
          tme += cycle['iterations']*sum(cycle['wait_times'])
          # Add the time for each individual move.
          for move in cycle['moves']:
              tme += cycle['iterations'] \
                  * move_time(move, eres=eres)
      # Done.
      return tme
docs: Calculates the time the move sequence will take to complete.
  
      Calculates the amount of time it will take to complete the given
      move sequence. Types of motion supported are moves from one position
      to another (the motion will always come to a stop before doing the
      next motion), waiting a given interval of time till starting the
      next move, and looping over a sequence of moves.
  
      Parameters
      ----------
      cycles : list of dicts
          The ``list`` of cycles of motion to do one after another. See
          ``compile_sequence`` for format.
      unit_converter : UnitConverter, optional
          ``GeminiMotorDrive.utilities.UnitConverter`` to use to convert
          the units in `cycles` to motor units. ``None`` indicates that
          they are already in motor units.
      eres : int
          Encoder resolution. Only relevant if `unit_converter` is
          ``None``.
  
  
      Returns
      -------
      time : float
          Time the move sequence will take in seconds.
  
      See Also
      --------
      compile_sequence
      GeminiMotorDrive.utilities.UnitConverter
      move_time