code: def _process(self):
          
          buffer = self.key_buffer
          retry = False
  
          while True:
              if retry:
                  retry = False
              else:
                  buffer.append((yield))
  
              # If we have some key presses, check for matches.
              if buffer:
                  is_prefix_of_longer_match = self._is_prefix_of_longer_match(buffer)
                  matches = self._get_matches(buffer)
  
                  # When eager matches were found, give priority to them and also
                  # ignore all the longer matches.
                  eager_matches = [m for m in matches if m.eager(self._cli_ref())]
  
                  if eager_matches:
                      matches = eager_matches
                      is_prefix_of_longer_match = False
  
                  # Exact matches found, call handler.
                  if not is_prefix_of_longer_match and matches:
                      self._call_handler(matches[-1], key_sequence=buffer[:])
                      del buffer[:]  # Keep reference.
  
                  # No match found.
                  elif not is_prefix_of_longer_match and not matches:
                      retry = True
                      found = False
  
                      # Loop over the input, try longest match first and shift.
                      for i in range(len(buffer), 0, -1):
                          matches = self._get_matches(buffer[:i])
                          if matches:
                              self._call_handler(matches[-1], key_sequence=buffer[:i])
                              del buffer[:i]
                              found = True
                              break
  
                      if not found:
                          del buffer[:1]
docs: Coroutine implementing the key match algorithm. Key strokes are sent
          into this generator, and it calls the appropriate handlers.