code: def feed(self, new_bytes):
          
          self._available_bytes += new_bytes
          callbacks = []
          try:
              while True:
                  packet = six.next(self._packet_generator)
                  if packet is None:
                      break
                  else:
                      callbacks.append(partial(self.packet_callback, packet))
          except Exception:
              # When we receive an exception, we assume that the _available_bytes
              # has already been updated and we just choked on a field.  That
              # is, unless the number of _available_bytes has not changed.  In
              # that case, we reset the buffered entirely
  
              # TODO: black hole may not be the best.  What should the logging
              # behavior be?
              self.reset()
  
          # callbacks are partials that are bound to packet already.  We do
          # this in order to separate out parsing activity (and error handling)
          # from the execution of callbacks.  Callbacks should not in any way
          # rely on the parsers position in the byte stream.
          for callback in callbacks:
              callback()
docs: Feed a new set of bytes into the protocol handler
  
          These bytes will be immediately fed into the parsing state machine and
          if new packets are found, the ``packet_callback`` will be executed
          with the fully-formed message.
  
          :param new_bytes: The new bytes to be fed into the stream protocol
              handler.