code: def call_all(self, requests):
          
          threads = []
  
          if 'gevent' in sys.modules:
              # assume that gevent is available and functional, make calls in parallel
              import gevent
              for r in requests:
                  req = self.protocol.create_request(r.method, r.args, r.kwargs)
                  tr = r.transport.transport if len(r) == 4 else None
                  threads.append(
                      gevent.spawn(
                          self._send_and_handle_reply, req, False, tr, True
                      )
                  )
              gevent.joinall(threads)
              return [t.value for t in threads]
          else:
              # call serially
              for r in requests:
                  req = self.protocol.create_request(r.method, r.args, r.kwargs)
                  tr = r.transport.transport if len(r) == 4 else None
                  threads.append(
                      self._send_and_handle_reply(req, False, tr, True)
                  )
              return threads
docs: Calls the methods in the request in parallel.
  
          When the :py:mod:`gevent` module is already loaded it is assumed to be
          correctly initialized, including monkey patching if necessary.
          In that case the RPC calls defined by ``requests`` is performed in
          parallel otherwise the methods are called sequentially.
  
          :param requests: A listof either :py:class:`~tinyrpc.client.RPCCall` or :py:class:`~tinyrpc.client.RPCCallTo` elements.
                           When RPCCallTo is used each element defines a transport.
                           Otherwise the default transport set when RPCClient is
                           created is used.
          :return: A list with replies matching the order of the requests.