code: async def apply_commandline(self, cmdline):
          
          # remove initial spaces
          cmdline = cmdline.lstrip()
  
          # we pass Commands one by one to `self.apply_command`.
          # To properly call them in sequence, even if they trigger asyncronous
          # code (return Deferreds), these applications happen in individual
          # callback functions which are then used as callback chain to some
          # trivial Deferred that immediately calls its first callback. This way,
          # one callback may return a Deferred and thus postpone the application
          # of the next callback (and thus Command-application)
  
          def apply_this_command(cmdstring):
              logging.debug('%s command string: "%s"', self.mode, str(cmdstring))
              # translate cmdstring into :class:`Command`
              cmd = commandfactory(cmdstring, self.mode)
              # store cmdline for use with 'repeat' command
              if cmd.repeatable:
                  self.last_commandline = cmdline
              return self.apply_command(cmd)
  
          try:
              for c in split_commandline(cmdline):
                  await apply_this_command(c)
          except Exception as e:
              self._error_handler(e)
docs: interprets a command line string
  
          i.e., splits it into separate command strings,
          instanciates :class:`Commands <alot.commands.Command>`
          accordingly and applies then in sequence.
  
          :param cmdline: command line to interpret
          :type cmdline: str