code: def send(self, request, ordered=False):
          
          if not self._user_connected:
              raise ConnectionError('Cannot send requests while disconnected')
  
          if not utils.is_list_like(request):
              state = RequestState(request, self._loop)
              self._send_queue.append(state)
              return state.future
          else:
              states = []
              futures = []
              state = None
              for req in request:
                  state = RequestState(req, self._loop, after=ordered and state)
                  states.append(state)
                  futures.append(state.future)
  
              self._send_queue.extend(states)
              return futures
docs: This method enqueues the given request to be sent. Its send
          state will be saved until a response arrives, and a ``Future``
          that will be resolved when the response arrives will be returned:
  
          .. code-block:: python
  
              async def method():
                  # Sending (enqueued for the send loop)
                  future = sender.send(request)
                  # Receiving (waits for the receive loop to read the result)
                  result = await future
  
          Designed like this because Telegram may send the response at
          any point, and it can send other items while one waits for it.
          Once the response for this future arrives, it is set with the
          received result, quite similar to how a ``receive()`` call
          would otherwise work.
  
          Since the receiving part is "built in" the future, it's
          impossible to await receive a result that was never sent.