code: async def recv_message(self):
          
          # TODO: check that messages were sent for non-stream-stream requests
          if not self._recv_initial_metadata_done:
              await self.recv_initial_metadata()
  
          with self._wrapper:
              message = await recv_message(self._stream, self._codec,
                                           self._recv_type)
              self._recv_message_count += 1
              message, = await self._dispatch.recv_message(message)
              return message
docs: Coroutine to receive incoming message from the server.
  
          If server sends UNARY response, then you can call this coroutine only
          once. If server sends STREAM response, then you should call this
          coroutine several times, until it returns None. To simplify you code in
          this case, :py:class:`Stream` implements async iterations protocol, so
          you can use it like this:
  
          .. code-block:: python3
  
              async for massage in stream:
                  do_smth_with(message)
  
          or even like this:
  
          .. code-block:: python3
  
              messages = [msg async for msg in stream]
  
          HTTP/2 has flow control mechanism, so client will acknowledge received
          DATA frames as a message only after user consumes this coroutine.
  
          :returns: message