Method wait_multiple

dwave/cloud/computation.py:249–348

Wait for multiple :class:`Future` objects to complete. Blocking call that uses an event object to emulate multi-wait for Python. Args: futures (list of Futures): List of :class:`Future` objects to await. min_done (int, optional, default=None

(futures, min_done=None, timeout=None)

    @staticmethod
    def wait_multiple(futures, min_done=None, timeout=None):
        """Wait for multiple :class:`Future` objects to complete.

        Blocking call that uses an event object to emulate multi-wait for Python.

        Args:
            futures (list of Futures):
                List of :class:`Future` objects to await.

            min_done (int, optional, default=None):
                Minimum required completions to end the waiting. The wait is
                terminated when this number of results are ready. If None, waits
                for all the :class:`Future` objects to complete.

            timeout (float, optional, default=None):
                Maximum number of seconds to await completion. If None, waits
                indefinitely.

        Returns:
            Two-tuple of :class:`Future` objects: completed and not completed
            submitted tasks. Similar to `concurrent.futures.wait()` method's
            returned two-tuple of `done` and `not_done` sets.

        See Also:
            :func:`as_completed` for a blocking iterable of resolved futures
            similar to `concurrent.futures.as_completed()` method.

        Examples:
            This example creates a solver using the local system's default
            D-Wave Cloud Client configuration file, submits a simple QUBO
            problem to a remote D-Wave resource 3 times for differing numbers of
            samples, and waits for sampling to complete on any two of the
            submissions. The wait ends with the completion of two submissions
            while the third is still in progress. (A more typical approach would
            use something like
            :code:`first = next(Future.as_completed(computation))` instead.)

            >>> import dwave.cloud as dc
            >>> client = dc.Client.from_config()  # doctest: +SKIP
            >>> solver = client.get_solver()      # doctest: +SKIP
            >>> u, v = next(iter(solver.edges))   # doctest: +SKIP
            >>> Q = {(u, u): -1, (u, v): 0, (v, u): 2, (v, v): -1}    # doctest: +SKIP
            >>> computation = [solver.sample_qubo(Q, num_reads=1000),
            ...                solver.sample_qubo(Q, num_reads=50),
            ...                solver.sample_qubo(Q, num_reads=10)]   # doctest: +SKIP
            >>> dc.computation.Future.wait_multiple(computation, min_done=1)    # doctest: +SKIP
            ([<dwave.cloud.computation.Future at 0x17dde518>,
              <dwave.cloud.computation.Future at 0x17ddee80>],
             [<dwave.cloud.computation.Future at 0x15078080>])
            >>> print(computation[0].done())   # doctest: +SKIP
            False
            >>> print(computation[1].done())  # doctest: +SKIP
            True
            >>> print(computation[2].done())   # doctest: +SKIP
            True
            >>> client.close()         # doctest: +SKIP

        """