code: def buffer(self):
          
          if self._buf_in_use:
              raise RuntimeError("nested use of buffer() is not supported")
          self._buf_in_use = True
          old_write = self._write
          old_flush = self._flush
  
          if self._buf is None:
              self._buf = io.BytesIO()
          else:
              try:
                  self._buf.seek(0)
                  self._buf.truncate()
              except BufferError:
                  # we need a fresh buffer for this, the other is still in use.
                  self._buf = io.BytesIO()
  
          self._write = self._buf.write
          self._flush = None
          try:
              with self._save_state():
                  yield
              old_write(self._buf.getbuffer())
              if old_flush:
                  old_flush()
          finally:
              self._buf_in_use = False
              self._write = old_write
              self._flush = old_flush
docs: Context manager to temporarily buffer the output.
  
          :raise RuntimeError: If two :meth:`buffer` context managers are used
                               nestedly.
  
          If the context manager is left without exception, the buffered output
          is sent to the actual sink. Otherwise, it is discarded.
  
          In addition to the output being buffered, buffer also captures the
          entire state of the XML generator and restores it to the previous state
          if the context manager is left with an exception.
  
          This can be used to fail-safely attempt to serialise a subtree and
          return to a well-defined state if serialisation fails.
  
          :meth:`flush` is not called automatically.
  
          If :meth:`flush` is called while a :meth:`buffer` context manager is
          active, no actual flushing happens (but unfinished opening tags are
          closed as usual, see the `short_empty_arguments` parameter).