docs: def call_actions_parallel_future(self, service_name, actions, **kwargs):
          """
          This method is identical in signature and behavior to `call_actions_parallel`, except that it sends the requests
          and then immediately returns a `FutureResponse` instead of blocking waiting on responses and returning a
          generator. Just call `result(timeout=None)` on the future response to block for an available response (which
          will be a generator). Some of the possible exceptions may be raised when this method is called; others may be
          raised when the future is used.
  
          If argument `raise_job_errors` is supplied and is `False`, some items in the result list might be lists of job
          errors instead of individual `ActionResponse`s. Be sure to check for that if used in this manner.
  
          If argument `catch_transport_errors` is supplied and is `True`, some items in the result list might be instances
          of `Exception` instead of individual `ActionResponse`s. Be sure to check for that if used in this manner.
  
          :return: A generator of action responses that blocks waiting on responses once you begin iteration
          :rtype: Client.FutureResponse
          """
          job_responses = self.call_jobs_parallel_future(
              jobs=({'service_name': service_name, 'actions': [action]} for action in actions),
              **kwargs
          )
  
          def parse_results(results):
              for job in results:
                  if isinstance(job, Exception):
                      yield job
                  elif job.errors:
                      yield job.errors
                  else:
                      yield job.actions[0]
  
          return self.FutureResponse(lambda _timeout: (x for x in parse_results(job_responses.result(_timeout))))