docs: def call_jobs_parallel(
          self,
          jobs,
          expansions=None,
          raise_job_errors=True,
          raise_action_errors=True,
          catch_transport_errors=False,
          timeout=None,
          **kwargs
      ):
          """
          Build and send multiple job requests to one or more services, each with one or more actions, to be executed in
          parallel, and return once all responses have been received.
  
          Returns a list of job responses, one for each job in the same order as provided, or raises an exception if any
          job response is an error (unless `raise_job_errors` is passed as `False`) or if any action response is an
          error (unless `raise_action_errors` is passed as `False`).
  
          This method performs expansions if the Client is configured with an expansion converter.
  
          :param jobs: A list of job request dicts, each containing `service_name` and `actions`, where `actions` is a
                       list of `ActionRequest` objects and/or dicts that can be converted to `ActionRequest` objects
          :type jobs: iterable[dict(service_name=union[str, unicode], actions=list[union[ActionRequest, dict]])]
          :param expansions: A dictionary representing the expansions to perform
          :type expansions: dict
          :param raise_job_errors: Whether to raise a JobError if any job responses contain errors (defaults to `True`)
          :type raise_job_errors: bool
          :param raise_action_errors: Whether to raise a CallActionError if any action responses contain errors (defaults
                                      to `True`)
          :type raise_action_errors: bool
          :param catch_transport_errors: Whether to catch transport errors and return them instead of letting them
                                         propagate. By default (`False`), the errors `ConnectionError`,
                                         `InvalidMessageError`, `MessageReceiveError`, `MessageReceiveTimeout`,
                                         `MessageSendError`, `MessageSendTimeout`, and `MessageTooLarge`, when raised by
                                         the transport, cause the entire process to terminate, potentially losing
                                         responses. If this argument is set to `True`, those errors are, instead, caught,
                                         and they are returned in place of their corresponding responses in the returned
                                         list of job responses.
          :type catch_transport_errors: bool
          :param timeout: If provided, this will override the default transport timeout values to; requests will expire
                          after this number of seconds plus some buffer defined by the transport, and the client will not
                          block waiting for a response for longer than this amount of time.
          :type timeout: int
          :param switches: A list of switch value integers
          :type switches: list
          :param correlation_id: The request correlation ID
          :type correlation_id: union[str, unicode]
          :param continue_on_error: Whether to continue executing further actions once one action has returned errors
          :type continue_on_error: bool
          :param context: A dictionary of extra values to include in the context header
          :type context: dict
          :param control_extra: A dictionary of extra values to include in the control header
          :type control_extra: dict
  
          :return: The job response
          :rtype: list[union(JobResponse, Exception)]
  
          :raise: ConnectionError, InvalidField, MessageSendError, MessageSendTimeout, MessageTooLarge,
                  MessageReceiveError, MessageReceiveTimeout, InvalidMessage, JobError, CallActionError
          """
          return self.call_jobs_parallel_future(
              jobs,
              expansions=expansions,
              raise_job_errors=raise_job_errors,
              raise_action_errors=raise_action_errors,
              catch_transport_errors=catch_transport_errors,
              timeout=timeout,
              **kwargs
          ).result()