class_docstr: Statemachine that receives :class:`KeyPress` instances and according to the
  key bindings in the given :class:`KeyBindings`, calls the matching handlers.
  
  ::
  
      p = KeyProcessor(key_bindings)
  
      # Send keys into the processor.
      p.feed(KeyPress(Keys.ControlX, ''))
      p.feed(KeyPress(Keys.ControlC, '')
  
      # Process all the keys in the queue.
      p.process_keys()
  
      # Now the ControlX-ControlC callback will be called if this sequence is
      # registered in the key bindings.
  
  :param key_bindings: `KeyBindingsBase` instance.
code: def reset(self) -> None:
      self._previous_key_sequence: list[KeyPress] = []
      self._previous_handler: Binding | None = None
  
      # The queue of keys not yet send to our _process generator/state machine.
      self.input_queue: deque[KeyPress] = deque()
  
      # The key buffer that is matched in the generator state machine.
      # (This is at at most the amount of keys that make up for one key binding.)
      self.key_buffer: list[KeyPress] = []
  
      #: Readline argument (for repetition of commands.)
      #: https://www.gnu.org/software/bash/manual/html_node/Readline-Arguments.html
      self.arg: str | None = None
  
      # Start the processor coroutine.
      self._process_coroutine = self._process()
      self._process_coroutine.send(None)
  
imports: from __future__ import annotations
  import weakref
  from asyncio import Task, sleep
  from collections import deque
  from typing import TYPE_CHECKING, Any, Generator
  from prompt_toolkit.application.current import get_app
  from prompt_toolkit.enums import EditingMode
  from prompt_toolkit.filters.app import vi_navigation_mode
  from prompt_toolkit.keys import Keys
  from prompt_toolkit.utils import Event
  from .key_bindings import Binding, KeyBindingsBase
label_desc: Use image node_id 2 for calling the KeyProcessor obj's underlying member method code with example usage: obj.reset() without return types