docs: def call_action_future(
          self,
          service_name,
          action,
          body=None,
          **kwargs
      ):
          """
          This method is identical in signature and behavior to `call_action`, except that it sends the request and
          then immediately returns a `FutureResponse` instead of blocking waiting on a response and returning
          an `ActionResponse`. 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 action response can later be retrieved
          :rtype: Client.FutureResponse
          """
          action_request = ActionRequest(
              action=action,
              body=body or {},
          )
          future = self.call_actions_future(
              service_name,
              [action_request],
              **kwargs
          )
  
          def get_result(_timeout):
              result = future.result(_timeout)
              if result.errors:
                  # This can only happen if raise_job_errors is set to False, so return the list of errors, just like
                  # other methods do below.
                  return result.errors
              return result.actions[0]
  
          return self.FutureResponse(get_result)