docs: def call_actions_future(
          self,
          service_name,
          actions,
          expansions=None,
          raise_job_errors=True,
          raise_action_errors=True,
          timeout=None,
          **kwargs
      ):
          """
          This method is identical in signature and behavior to `call_actions`, except that it sends the request and
          then immediately returns a `FutureResponse` instead of blocking waiting on a response and returning a
          `JobResponse`. Just call `result(timeout=None)` on the future response to block for an available
          response. Some of the possible exceptions may be raised when this method is called; others may be raised when
          the future is used.
  
          :return: A future from which the job response can later be retrieved
          :rtype: Client.FutureResponse
          """
          kwargs.pop('suppress_response', None)  # If this kwarg is used, this method would always result in a timeout
          if timeout:
              kwargs['message_expiry_in_seconds'] = timeout
  
          expected_request_id = self.send_request(service_name, actions, **kwargs)
  
          def get_response(_timeout=None):
              # Get all responses
              responses = list(self.get_all_responses(service_name, receive_timeout_in_seconds=_timeout or timeout))
  
              # Try to find the expected response
              found = False
              response = None
              for request_id, response in responses:
                  if request_id == expected_request_id:
                      found = True
                      break
              if not found:
                  # This error should be impossible if `get_all_responses` is behaving correctly, but let's raise a
                  # meaningful error just in case.
                  raise Exception(
                      'Got unexpected response(s) with ID(s) {} for request with ID {}'.format(
                          [r[0] for r in responses],
                          expected_request_id,
                      )
                  )
  
              # Process errors at the Job and Action level
              if response.errors and raise_job_errors:
                  raise self.JobError(response.errors)
              if raise_action_errors:
                  error_actions = [action for action in response.actions if action.errors]
                  if error_actions:
                      raise self.CallActionError(error_actions)
  
              if expansions:
                  kwargs.pop('continue_on_error', None)
                  self._perform_expansion(response.actions, expansions, **kwargs)
  
              return response
  
          return self.FutureResponse(get_response)