Skip to content
Linting

Properly convert finalize dependencies to references (#8949) #14443

Sign in to view logs

Properly convert finalize dependencies to references (#8949)

Properly convert finalize dependencies to references (#8949) #14443

GitHub Actions / Unit Test Results failed Nov 26, 2024 in 0s

6 fail, 111 skipped, 4 013 pass in 12h 24m 45s

    29 files  ±0      29 suites  ±0   12h 24m 45s ⏱️ + 9m 38s
 4 130 tests ±0   4 013 ✅  -  2    111 💤 ±0  6 ❌ + 2 
55 839 runs  ±0  53 405 ✅ +35  2 426 💤  - 1  8 ❌  - 34 

Results for commit 0660dab. ± Comparison against earlier commit b57cb2c.

Annotations

Check warning on line 0 in distributed.cli.tests.test_dask_spec

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

1 out of 14 runs failed: test_errors (distributed.cli.tests.test_dask_spec) 

artifacts/ubuntu-latest-3.10-no_expr-notci1/pytest.xml [took 11s]
Raw output 
subprocess.TimeoutExpired: Command '['/home/runner/miniconda3/envs/dask-distributed/bin/dask', 'spec']' timed out after 10 seconds
def test_errors():
        with popen(
            [
                "dask",
                "spec",
                "--spec",
                '{"foo": "bar"}',
                "--spec-file",
                "foo.yaml",
            ],
            capture_output=True,
        ) as proc:
            line = proc.stdout.readline().decode()
            assert "exactly one" in line
            assert "--spec" in line and "--spec-file" in line
    
>       with popen(["dask", "spec"], capture_output=True) as proc:

distributed/cli/tests/test_dask_spec.py:88: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../../../miniconda3/envs/dask-distributed/lib/python3.10/contextlib.py:142: in __exit__
    next(self.gen)
distributed/utils_test.py:1204: in popen
    _terminate_process(proc, terminate_timeout)
distributed/utils_test.py:1130: in _terminate_process
    proc.communicate(timeout=terminate_timeout)
../../../miniconda3/envs/dask-distributed/lib/python3.10/subprocess.py:1154: in communicate
    stdout, stderr = self._communicate(input, endtime, timeout)
../../../miniconda3/envs/dask-distributed/lib/python3.10/subprocess.py:2022: in _communicate
    self._check_timeout(endtime, orig_timeout, stdout, stderr)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <Popen: returncode: -9 args: ['/home/runner/miniconda3/envs/dask-distributed...>
endtime = 456.206917814, orig_timeout = 10
stdout_seq = [b'Exception ignored in atexit callback: <function _python_exit at 0x7fd96fb4ab00>\nTraceback (most recent call last):...coverage/collector.py", line 254, in unlock_data\n', b'    def unlock_data(self) -> None:\nKeyboardInterrupt: \n', b'']
stderr_seq = None, skip_check_and_raise = False

    def _check_timeout(self, endtime, orig_timeout, stdout_seq, stderr_seq,
                       skip_check_and_raise=False):
        """Convenience for checking if a timeout has expired."""
        if endtime is None:
            return
        if skip_check_and_raise or _time() > endtime:
>           raise TimeoutExpired(
                    self.args, orig_timeout,
                    output=b''.join(stdout_seq) if stdout_seq else None,
                    stderr=b''.join(stderr_seq) if stderr_seq else None)
E           subprocess.TimeoutExpired: Command '['/home/runner/miniconda3/envs/dask-distributed/bin/dask', 'spec']' timed out after 10 seconds

../../../miniconda3/envs/dask-distributed/lib/python3.10/subprocess.py:1198: TimeoutExpired

Check warning on line 0 in distributed.comm.tests.test_comms

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

3 out of 14 runs failed: test_tls_comm_closed_implicit[tornado] (distributed.comm.tests.test_comms) 

artifacts/ubuntu-latest-3.11-default-notci1/pytest.xml [took 0s]
artifacts/ubuntu-latest-3.12-default-notci1/pytest.xml [took 0s]
artifacts/ubuntu-latest-3.13-default-notci1/pytest.xml [took 0s]
Raw output 
ssl.SSLError: [SYS] unknown error (_ssl.c:2580)
tcp = <module 'distributed.comm.tcp' from '/home/runner/work/distributed/distributed/distributed/comm/tcp.py'>

    @gen_test()
    async def test_tls_comm_closed_implicit(tcp):
>       await check_comm_closed_implicit("tls://127.0.0.1", **tls_kwargs)

distributed/comm/tests/test_comms.py:777: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
distributed/comm/tests/test_comms.py:763: in check_comm_closed_implicit
    await comm.read()
distributed/comm/tcp.py:225: in read
    frames_nosplit_nbytes_bin = await stream.read_bytes(fmt_size)
../../../miniconda3/envs/dask-distributed/lib/python3.11/site-packages/tornado/iostream.py:422: in read_bytes
    self._try_inline_read()
../../../miniconda3/envs/dask-distributed/lib/python3.11/site-packages/tornado/iostream.py:836: in _try_inline_read
    pos = self._read_to_buffer_loop()
../../../miniconda3/envs/dask-distributed/lib/python3.11/site-packages/tornado/iostream.py:750: in _read_to_buffer_loop
    if self._read_to_buffer() == 0:
../../../miniconda3/envs/dask-distributed/lib/python3.11/site-packages/tornado/iostream.py:861: in _read_to_buffer
    bytes_read = self.read_from_fd(buf)
../../../miniconda3/envs/dask-distributed/lib/python3.11/site-packages/tornado/iostream.py:1552: in read_from_fd
    return self.socket.recv_into(buf, len(buf))
../../../miniconda3/envs/dask-distributed/lib/python3.11/ssl.py:1314: in recv_into
    return self.read(nbytes, buffer)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <ssl.SSLSocket [closed] fd=-1, family=2, type=1, proto=0>, len = 65536
buffer = bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x...0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')

    def read(self, len=1024, buffer=None):
        """Read up to LEN bytes and return them.
        Return zero-length string on EOF."""
    
        self._checkClosed()
        if self._sslobj is None:
            raise ValueError("Read on closed or unwrapped SSL socket.")
        try:
            if buffer is not None:
>               return self._sslobj.read(len, buffer)
E               ssl.SSLError: [SYS] unknown error (_ssl.c:2580)

../../../miniconda3/envs/dask-distributed/lib/python3.11/ssl.py:1166: SSLError

Check warning on line 0 in distributed.diagnostics.tests.test_task_stream

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

1 out of 14 runs failed: test_get_task_stream_save (distributed.diagnostics.tests.test_task_stream) 

artifacts/windows-latest-3.11-default-notci1/pytest.xml [took 4s]
Raw output 
assert 'inc' in '<!DOCTYPE html>\n<html lang="en">\n  <head>\n    <meta charset="utf-8">\n    <title>Dask Task Stream</title>\n    <style>\n      html, body {\n        box-sizing: border-box;\n        display: flow-root;\n        height: 100%;\n        margin: 0;\n        padding: 0;\n      }\n    </style>\n    <script type="text/javascript" src="https://cdn.bokeh.org/bokeh/release/bokeh-3.6.1.min.js"></script>\n    <script type="text/javascript">\n        Bokeh.set_log_level("info");\n    </script>\n  </head>\n  <body>\n    <div id="e902919d-33b1-483f-b81f-c54d5d1b65aa" data-root-id="p23072" style="display: contents;"></div>\n  \n    <script type="application/json" id="b72addff-6e90-4507-b6f9-c68f578d4716">\n      {"4037d87b-29ee-4900-a1c5-5d46d06b95b3":{"version":"3.6.1","title":"Bokeh Application","roots":[{"type":"object","name":"Figure","id":"p23072","attributes":{"name":"task_stream","sizing_mode":"stretch_both","x_range":{"type":"object","name":"DataRange1d","id":"p23070","attributes":{"range_padding":0}},"y_range":{"type":"object","name":"DataRange1d","id":"p23071","attributes":{"range_padding":0}},"x_scale":{"type":"object","name":"LinearScale","id":"p23082"},"y_scale":{"type":"object",...c68f578d4716\').textContent;\n              const render_items = [{"docid":"4037d87b-29ee-4900-a1c5-5d46d06b95b3","roots":{"p23072":"e902919d-33b1-483f-b81f-c54d5d1b65aa"},"root_ids":["p23072"]}];\n              root.Bokeh.embed.embed_items(docs_json, render_items);\n              }\n              if (root.Bokeh !== undefined) {\n                embed_document(root);\n              } else {\n                let attempts = 0;\n                const timer = setInterval(function(root) {\n                  if (root.Bokeh !== undefined) {\n                    clearInterval(timer);\n                    embed_document(root);\n                  } else {\n                    attempts++;\n                    if (attempts > 100) {\n                      clearInterval(timer);\n                      console.log("Bokeh: ERROR: Unable to run BokehJS code because BokehJS library is missing");\n                    }\n                  }\n                }, 10, root)\n              }\n            })(window);\n          });\n        };\n        if (document.readyState != "loading") fn();\n        else document.addEventListener("DOMContentLoaded", fn);\n      })();\n    </script>\n  </body>\n</html>'
client = <Client: 'tcp://127.0.0.1:57036' processes=2 threads=2, memory=32.00 GiB>
tmp_path = WindowsPath('C:/Users/runneradmin/AppData/Local/Temp/pytest-of-runneradmin/pytest-0/test_get_task_stream_save0')

    def test_get_task_stream_save(client, tmp_path):
        bkm = pytest.importorskip("bokeh.models")
        tmpdir = str(tmp_path)
        fn = os.path.join(tmpdir, "foo.html")
    
        with get_task_stream(plot="save", filename=fn) as ts:
            wait(client.map(inc, range(10)))
        with open(fn) as f:
            data = f.read()
>       assert "inc" in data
E       assert 'inc' in '<!DOCTYPE html>\n<html lang="en">\n  <head>\n    <meta charset="utf-8">\n    <title>Dask Task Stream</title>\n    <style>\n      html, body {\n        box-sizing: border-box;\n        display: flow-root;\n        height: 100%;\n        margin: 0;\n        padding: 0;\n      }\n    </style>\n    <script type="text/javascript" src="https://cdn.bokeh.org/bokeh/release/bokeh-3.6.1.min.js"></script>\n    <script type="text/javascript">\n        Bokeh.set_log_level("info");\n    </script>\n  </head>\n  <body>\n    <div id="e902919d-33b1-483f-b81f-c54d5d1b65aa" data-root-id="p23072" style="display: contents;"></div>\n  \n    <script type="application/json" id="b72addff-6e90-4507-b6f9-c68f578d4716">\n      {"4037d87b-29ee-4900-a1c5-5d46d06b95b3":{"version":"3.6.1","title":"Bokeh Application","roots":[{"type":"object","name":"Figure","id":"p23072","attributes":{"name":"task_stream","sizing_mode":"stretch_both","x_range":{"type":"object","name":"DataRange1d","id":"p23070","attributes":{"range_padding":0}},"y_range":{"type":"object","name":"DataRange1d","id":"p23071","attributes":{"range_padding":0}},"x_scale":{"type":"object","name":"LinearScale","id":"p23082"},"y_scale":{"type":"object",...c68f578d4716\').textContent;\n              const render_items = [{"docid":"4037d87b-29ee-4900-a1c5-5d46d06b95b3","roots":{"p23072":"e902919d-33b1-483f-b81f-c54d5d1b65aa"},"root_ids":["p23072"]}];\n              root.Bokeh.embed.embed_items(docs_json, render_items);\n              }\n              if (root.Bokeh !== undefined) {\n                embed_document(root);\n              } else {\n                let attempts = 0;\n                const timer = setInterval(function(root) {\n                  if (root.Bokeh !== undefined) {\n                    clearInterval(timer);\n                    embed_document(root);\n                  } else {\n                    attempts++;\n                    if (attempts > 100) {\n                      clearInterval(timer);\n                      console.log("Bokeh: ERROR: Unable to run BokehJS code because BokehJS library is missing");\n                    }\n                  }\n                }, 10, root)\n              }\n            })(window);\n          });\n        };\n        if (document.readyState != "loading") fn();\n        else document.addEventListener("DOMContentLoaded", fn);\n      })();\n    </script>\n  </body>\n</html>'

distributed\diagnostics\tests\test_task_stream.py:159: AssertionError

Check warning on line 0 in distributed.shuffle.tests.test_shuffle

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

1 out of 12 runs failed: test_raise_on_incompatible_partitions (distributed.shuffle.tests.test_shuffle) 

artifacts/windows-latest-3.12-default-notci1/pytest.xml [took 2s]
Raw output 
RuntimeError: Unexpected error encountered during P2P barrier: Exception("ArrowTypeError('Unable to merge: Field b has incompatible types: double vs large_string')")
c = <Client: No scheduler connected>
s = <Scheduler 'tcp://127.0.0.1:63906', workers: 0, cores: 0, tasks: 0>
a = <Worker 'tcp://127.0.0.1:63907', name: 0, status: closed, stored: 0, running: 0/1, ready: 0, comm: 0, waiting: 0>
b = <Worker 'tcp://127.0.0.1:63910', name: 1, status: closed, stored: 0, running: 0/2, ready: 0, comm: 0, waiting: 0>

    @gen_cluster(client=True)
    async def test_raise_on_incompatible_partitions(c, s, a, b):
        def make_partition(i):
            """Return incompatible column types for every other partition"""
            if i % 2 == 1:
                return pd.DataFrame({"a": np.random.random(10), "b": ["a"] * 10})
            return pd.DataFrame({"a": np.random.random(10), "b": np.random.random(10)})
    
        ddf = dd.from_map(make_partition, range(50))
        with dask.config.set({"dataframe.shuffle.method": "p2p"}):
            out = ddf.shuffle(on="a", ignore_index=True)
    
        with raises_with_cause(
            RuntimeError,
            r"P2P \w* failed",
            pa.ArrowTypeError,
            "incompatible types",
        ):
>           await c.compute(out)

distributed\shuffle\tests\test_shuffle.py:2586: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
distributed\client.py:410: in _result
    raise exc.with_traceback(tb)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

    from __future__ import annotations
    
    import abc
    import asyncio
    import contextlib
    import itertools
    import pickle
    import time
    from collections.abc import (
        Callable,
        Coroutine,
        Generator,
        Hashable,
        Iterable,
        Iterator,
        Sequence,
    )
    from concurrent.futures import ThreadPoolExecutor
    from dataclasses import dataclass, field
    from enum import Enum
    from functools import partial
    from pathlib import Path
    from typing import TYPE_CHECKING, Any, Generic, NewType, TypeVar, cast
    
    from tornado.ioloop import IOLoop
    
    import dask.config
    from dask._task_spec import Task
    from dask.core import flatten
    from dask.typing import Key
    from dask.utils import parse_bytes, parse_timedelta
    
    from distributed.core import ErrorMessage, OKMessage, PooledRPCCall, error_message
    from distributed.exceptions import Reschedule
    from distributed.metrics import context_meter, thread_time
    from distributed.protocol import to_serialize
    from distributed.protocol.serialize import ToPickle
    from distributed.shuffle._comms import CommShardsBuffer
    from distributed.shuffle._disk import DiskShardsBuffer
    from distributed.shuffle._exceptions import (
        P2PConsistencyError,
        P2POutOfDiskError,
        ShuffleClosedError,
    )
    from distributed.shuffle._limiter import ResourceLimiter
    from distributed.shuffle._memory import MemoryShardsBuffer
    from distributed.utils import run_in_executor_with_context, sync
    from distributed.utils_comm import retry
    
    if TYPE_CHECKING:
        # TODO import from typing (requires Python >=3.10)
        from typing_extensions import ParamSpec, TypeAlias
    
        _P = ParamSpec("_P")
    
        # circular dependencies
        from distributed.shuffle._worker_plugin import ShuffleWorkerPlugin
    
    ShuffleId = NewType("ShuffleId", str)
    NDIndex: TypeAlias = tuple[int, ...]
    
    
    _T_partition_id = TypeVar("_T_partition_id")
    _T_partition_type = TypeVar("_T_partition_type")
    _T = TypeVar("_T")
    
    
    class RunSpecMessage(OKMessage):
        run_spec: ShuffleRunSpec | ToPickle[ShuffleRunSpec]
    
    
    class ShuffleRun(Generic[_T_partition_id, _T_partition_type]):
        id: ShuffleId
        run_id: int
        span_id: str | None
        local_address: str
        executor: ThreadPoolExecutor
        rpc: Callable[[str], PooledRPCCall]
        digest_metric: Callable[[Hashable, float], None]
        scheduler: PooledRPCCall
        closed: bool
        _disk_buffer: DiskShardsBuffer | MemoryShardsBuffer
        _comm_buffer: CommShardsBuffer
        received: set[_T_partition_id]
        total_recvd: int
        start_time: float
        _exception: Exception | None
        _closed_event: asyncio.Event
        _loop: IOLoop
    
        RETRY_COUNT: int
        RETRY_DELAY_MIN: float
        RETRY_DELAY_MAX: float
    
        def __init__(
            self,
            id: ShuffleId,
            run_id: int,
            span_id: str | None,
            local_address: str,
            directory: str,
            executor: ThreadPoolExecutor,
            rpc: Callable[[str], PooledRPCCall],
            digest_metric: Callable[[Hashable, float], None],
            scheduler: PooledRPCCall,
            memory_limiter_disk: ResourceLimiter,
            memory_limiter_comms: ResourceLimiter,
            disk: bool,
            loop: IOLoop,
        ):
            self.id = id
            self.run_id = run_id
            self.span_id = span_id
            self.local_address = local_address
            self.executor = executor
            self.rpc = rpc
            self.digest_metric = digest_metric
            self.scheduler = scheduler
            self.closed = False
    
            # Initialize buffers and start background tasks
            # Don't log metrics issued by the background tasks onto the dask task that
            # spawned this object
            with context_meter.clear_callbacks():
                with self._capture_metrics("background-disk"):
                    if disk:
                        self._disk_buffer = DiskShardsBuffer(
                            directory=directory,
                            read=self.read,
                            memory_limiter=memory_limiter_disk,
                        )
                    else:
                        self._disk_buffer = MemoryShardsBuffer(deserialize=self.deserialize)
    
                with self._capture_metrics("background-comms"):
                    max_message_size = parse_bytes(
                        dask.config.get("distributed.p2p.comm.message-bytes-limit")
                    )
                    concurrency_limit = dask.config.get("distributed.p2p.comm.concurrency")
                    self._comm_buffer = CommShardsBuffer(
                        send=self.send,
                        max_message_size=max_message_size,
                        memory_limiter=memory_limiter_comms,
                        concurrency_limit=concurrency_limit,
                    )
    
            # TODO: reduce number of connections to number of workers
            # MultiComm.max_connections = min(10, n_workers)
    
            self.transferred = False
            self.received = set()
            self.total_recvd = 0
            self.start_time = time.time()
            self._exception = None
            self._closed_event = asyncio.Event()
            self._loop = loop
    
            self.RETRY_COUNT = dask.config.get("distributed.p2p.comm.retry.count")
            self.RETRY_DELAY_MIN = parse_timedelta(
                dask.config.get("distributed.p2p.comm.retry.delay.min"), default="s"
            )
            self.RETRY_DELAY_MAX = parse_timedelta(
                dask.config.get("distributed.p2p.comm.retry.delay.max"), default="s"
            )
    
        def __repr__(self) -> str:
            return f"<{self.__class__.__name__}: id={self.id!r}, run_id={self.run_id!r}, local_address={self.local_address!r}, closed={self.closed!r}, transferred={self.transferred!r}>"
    
        def __str__(self) -> str:
            return f"{self.__class__.__name__}<{self.id}[{self.run_id}]> on {self.local_address}"
    
        def __hash__(self) -> int:
            return self.run_id
    
        @contextlib.contextmanager
        def _capture_metrics(self, where: str) -> Iterator[None]:
            """Capture context_meter metrics as
    
                {('p2p', <span id>, 'foreground|background...', label, unit): value}
    
            **Note 1:** When the metric is not logged by a background task
            (where='foreground'), this produces a duplicated metric under
    
                {('execute', <span id>, <task prefix>, label, unit): value}
    
            This is by design so that one can have a holistic view of the whole shuffle
            process.
    
            **Note 2:** We're immediately writing to Worker.digests.
            We don't temporarily store metrics under ShuffleRun as we would lose those
            recorded between the heartbeat and when the ShuffleRun object is deleted at the
            end of a run.
            """
    
            def callback(label: Hashable, value: float, unit: str) -> None:
                if not isinstance(label, tuple):
                    label = (label,)
                if isinstance(label[0], str) and label[0].startswith("p2p-"):
                    label = (label[0][len("p2p-") :], *label[1:])
                name = ("p2p", self.span_id, where, *label, unit)
    
                self.digest_metric(name, value)
    
            with context_meter.add_callback(callback, allow_offload="background" in where):
                yield
    
        async def barrier(self, run_ids: Sequence[int]) -> int:
            self.raise_if_closed()
            consistent = all(run_id == self.run_id for run_id in run_ids)
            # TODO: Consider broadcast pinging once when the shuffle starts to warm
            # up the comm pool on scheduler side
            await self.scheduler.shuffle_barrier(
                id=self.id, run_id=self.run_id, consistent=consistent
            )
            return self.run_id
    
        async def _send(
            self, address: str, shards: list[tuple[_T_partition_id, Any]] | bytes
        ) -> OKMessage | ErrorMessage:
            self.raise_if_closed()
            return await self.rpc(address).shuffle_receive(
                data=to_serialize(shards),
                shuffle_id=self.id,
                run_id=self.run_id,
            )
    
        async def send(
            self, address: str, shards: list[tuple[_T_partition_id, Any]]
        ) -> OKMessage | ErrorMessage:
            if _mean_shard_size(shards) < 65536:
                # Don't send buffers individually over the tcp comms.
                # Instead, merge everything into an opaque bytes blob, send it all at once,
                # and unpickle it on the other side.
                # Performance tests informing the size threshold:
                # https://github.com/dask/distributed/pull/8318
                shards_or_bytes: list | bytes = pickle.dumps(shards)
            else:
                shards_or_bytes = shards
    
            def _send() -> Coroutine[Any, Any, OKMessage | ErrorMessage]:
                return self._send(address, shards_or_bytes)
    
            return await retry(
                _send,
                count=self.RETRY_COUNT,
                delay_min=self.RETRY_DELAY_MIN,
                delay_max=self.RETRY_DELAY_MAX,
            )
    
        async def offload(
            self, func: Callable[_P, _T], *args: _P.args, **kwargs: _P.kwargs
        ) -> _T:
            self.raise_if_closed()
            with context_meter.meter("offload"):
                return await run_in_executor_with_context(
                    self.executor, func, *args, **kwargs
                )
    
        def heartbeat(self) -> dict[str, Any]:
            comm_heartbeat = self._comm_buffer.heartbeat()
            comm_heartbeat["read"] = self.total_recvd
            return {
                "disk": self._disk_buffer.heartbeat(),
                "comm": comm_heartbeat,
                "start": self.start_time,
            }
    
        async def _write_to_comm(
            self, data: dict[str, tuple[_T_partition_id, Any]]
        ) -> None:
            self.raise_if_closed()
            await self._comm_buffer.write(data)
    
        async def _write_to_disk(self, data: dict[NDIndex, Any]) -> None:
            self.raise_if_closed()
            await self._disk_buffer.write(
                {"_".join(str(i) for i in k): v for k, v in data.items()}
            )
    
        def raise_if_closed(self) -> None:
            if self.closed:
                if self._exception:
                    raise self._exception
                raise ShuffleClosedError(f"{self} has already been closed")
    
        async def inputs_done(self) -> None:
            self.raise_if_closed()
            self.transferred = True
            await self._flush_comm()
            try:
                self._comm_buffer.raise_on_exception()
            except Exception as e:
                self._exception = e
                raise
    
        async def _flush_comm(self) -> None:
            self.raise_if_closed()
            await self._comm_buffer.flush()
    
        async def flush_receive(self) -> None:
            self.raise_if_closed()
            await self._disk_buffer.flush()
    
        async def close(self) -> None:
            if self.closed:  # pragma: no cover
                await self._closed_event.wait()
                return
    
            self.closed = True
            await self._comm_buffer.close()
            await self._disk_buffer.close()
            self._closed_event.set()
    
        def fail(self, exception: Exception) -> None:
            if not self.closed:
                self._exception = exception
    
        def _read_from_disk(self, id: NDIndex) -> list[Any]:  # TODO: Typing
            self.raise_if_closed()
            return self._disk_buffer.read("_".join(str(i) for i in id))
    
        async def receive(
            self, data: list[tuple[_T_partition_id, Any]] | bytes
        ) -> OKMessage | ErrorMessage:
            try:
                if isinstance(data, bytes):
                    # Unpack opaque blob. See send()
                    data = cast(list[tuple[_T_partition_id, Any]], pickle.loads(data))
                await self._receive(data)
                return {"status": "OK"}
            except P2PConsistencyError as e:
                return error_message(e)
    
        async def _ensure_output_worker(self, i: _T_partition_id, key: Key) -> None:
            assigned_worker = self._get_assigned_worker(i)
    
            if assigned_worker != self.local_address:
                result = await self.scheduler.shuffle_restrict_task(
                    id=self.id, run_id=self.run_id, key=key, worker=assigned_worker
                )
                if result["status"] == "error":
                    raise RuntimeError(result["message"])
                assert result["status"] == "OK"
                raise Reschedule()
    
        @abc.abstractmethod
        def _get_assigned_worker(self, i: _T_partition_id) -> str:
            """Get the address of the worker assigned to the output partition"""
    
        @abc.abstractmethod
        async def _receive(self, data: list[tuple[_T_partition_id, Any]]) -> None:
            """Receive shards belonging to output partitions of this shuffle run"""
    
        def add_partition(
            self, data: _T_partition_type, partition_id: _T_partition_id
        ) -> int:
            self.raise_if_closed()
            if self.transferred:
                raise RuntimeError(f"Cannot add more partitions to {self}")
            # Log metrics both in the "execute" and in the "p2p" contexts
            self.validate_data(data)
            with self._capture_metrics("foreground"):
                with (
                    context_meter.meter("p2p-shard-partition-noncpu"),
                    context_meter.meter("p2p-shard-partition-cpu", func=thread_time),
                ):
                    shards = self._shard_partition(data, partition_id)
                sync(self._loop, self._write_to_comm, shards)
            return self.run_id
    
        @abc.abstractmethod
        def _shard_partition(
            self, data: _T_partition_type, partition_id: _T_partition_id
        ) -> dict[str, tuple[_T_partition_id, Any]]:
            """Shard an input partition by the assigned output workers"""
    
        def get_output_partition(
            self, partition_id: _T_partition_id, key: Key, **kwargs: Any
        ) -> _T_partition_type:
            self.raise_if_closed()
            sync(self._loop, self._ensure_output_worker, partition_id, key)
            if not self.transferred:
                raise RuntimeError("`get_output_partition` called before barrier task")
            sync(self._loop, self.flush_receive)
            with (
                # Log metrics both in the "execute" and in the "p2p" contexts
                self._capture_metrics("foreground"),
                context_meter.meter("p2p-get-output-noncpu"),
                context_meter.meter("p2p-get-output-cpu", func=thread_time),
            ):
                return self._get_output_partition(partition_id, key, **kwargs)
    
        @abc.abstractmethod
        def _get_output_partition(
            self, partition_id: _T_partition_id, key: Key, **kwargs: Any
        ) -> _T_partition_type:
            """Get an output partition to the shuffle run"""
    
        @abc.abstractmethod
        def read(self, path: Path) -> tuple[Any, int]:
            """Read shards from disk"""
    
        @abc.abstractmethod
        def deserialize(self, buffer: Any) -> Any:
            """Deserialize shards"""
    
        def validate_data(self, data: Any) -> None:
            """Validate payload data before shuffling"""
    
    
    def get_worker_plugin() -> ShuffleWorkerPlugin:
        from distributed import get_worker
    
        try:
            worker = get_worker()
        except ValueError as e:
            raise RuntimeError(
                "`shuffle='p2p'` requires Dask's distributed scheduler. This task is not running on a Worker; "
                "please confirm that you've created a distributed Client and are submitting this computation through it."
            ) from e
        try:
            return worker.plugins["shuffle"]  # type: ignore
        except KeyError as e:
            raise RuntimeError(
                f"The worker {worker.address} does not have a P2P shuffle plugin."
            ) from e
    
    
    _BARRIER_PREFIX = "shuffle-barrier-"
    
    
    def barrier_key(shuffle_id: ShuffleId) -> str:
        return _BARRIER_PREFIX + shuffle_id
    
    
    def id_from_key(key: Key) -> ShuffleId | None:
        if not isinstance(key, str) or not key.startswith(_BARRIER_PREFIX):
            return None
        return ShuffleId(key[len(_BARRIER_PREFIX) :])
    
    
    class ShuffleType(Enum):
        DATAFRAME = "DataFrameShuffle"
        ARRAY_RECHUNK = "ArrayRechunk"
    
    
    @dataclass(frozen=True)
    class ShuffleRunSpec(Generic[_T_partition_id]):
        run_id: int = field(init=False, default_factory=partial(next, itertools.count(1)))
        spec: ShuffleSpec
        worker_for: dict[_T_partition_id, str]
        span_id: str | None
    
        @property
        def id(self) -> ShuffleId:
            return self.spec.id
    
    
    @dataclass(frozen=True)
    class ShuffleSpec(abc.ABC, Generic[_T_partition_id]):
        id: ShuffleId
        disk: bool
    
        @property
        @abc.abstractmethod
        def output_partitions(self) -> Generator[_T_partition_id]:
            """Output partitions"""
    
        @abc.abstractmethod
        def pick_worker(self, partition: _T_partition_id, workers: Sequence[str]) -> str:
            """Pick a worker for a partition"""
    
        def create_new_run(
            self,
            worker_for: dict[_T_partition_id, str],
            span_id: str | None,
        ) -> SchedulerShuffleState:
            return SchedulerShuffleState(
                run_spec=ShuffleRunSpec(spec=self, worker_for=worker_for, span_id=span_id),
                participating_workers=set(worker_for.values()),
            )
    
        @abc.abstractmethod
        def create_run_on_worker(
            self,
            run_id: int,
            span_id: str | None,
            worker_for: dict[_T_partition_id, str],
            plugin: ShuffleWorkerPlugin,
        ) -> ShuffleRun:
            """Create the new shuffle run on the worker."""
    
    
    @dataclass(eq=False)
    class SchedulerShuffleState(Generic[_T_partition_id]):
        run_spec: ShuffleRunSpec
        participating_workers: set[str]
        _archived_by: str | None = field(default=None, init=False)
        _failed: bool = False
    
        @property
        def id(self) -> ShuffleId:
            return self.run_spec.id
    
        @property
        def run_id(self) -> int:
            return self.run_spec.run_id
    
        @property
        def archived(self) -> bool:
            return self._archived_by is not None
    
        def __str__(self) -> str:
            return f"{self.__class__.__name__}<{self.id}[{self.run_id}]>"
    
        def __hash__(self) -> int:
            return hash(self.run_id)
    
    
    @contextlib.contextmanager
    def handle_transfer_errors(id: ShuffleId) -> Iterator[None]:
        try:
            yield
        except ShuffleClosedError:
            raise Reschedule()
        except P2PConsistencyError:
            raise
        except P2POutOfDiskError:
            raise
        except Exception as e:
            raise RuntimeError(f"P2P {id} failed during transfer phase") from e
    
    
    @contextlib.contextmanager
    def handle_unpack_errors(id: ShuffleId) -> Iterator[None]:
        try:
            yield
        except Reschedule as e:
            raise e
        except ShuffleClosedError:
            raise Reschedule()
        except P2PConsistencyError:
            raise
        except P2POutOfDiskError:
            raise
        except Exception as e:
            raise RuntimeError(f"P2P {id} failed during unpack phase") from e
    
    
    def _handle_datetime(buf: Any) -> Any:
        if hasattr(buf, "dtype") and buf.dtype.kind in "Mm":
            return buf.view("u8")
        return buf
    
    
    def _mean_shard_size(shards: Iterable) -> int:
        """Return estimated mean size in bytes of each shard"""
        size = 0
        count = 0
        for shard in flatten(shards, container=(tuple, list)):
            if not isinstance(shard, int):
                # This also asserts that shard is a Buffer and that we didn't forget
                # a container or metadata type above
                shard = _handle_datetime(shard)
                size += memoryview(shard).nbytes
                count += 1
                if count == 10:
                    break
        return size // count if count else 0
    
    
    def p2p_barrier(id: ShuffleId, *run_ids: int) -> int:
        try:
            return get_worker_plugin().barrier(id, run_ids)
        except Reschedule as e:
            raise e
        except P2PConsistencyError:
            raise
        except P2POutOfDiskError:
            raise
        except Exception as e:
>           raise RuntimeError(f"P2P {id} failed during barrier phase") from e
E           RuntimeError: P2P ceede566863a211aa906824d719b5b6c failed during barrier phase

distributed\shuffle\_core.py:582: RuntimeError

During handling of the above exception, another exception occurred:

c = <Client: No scheduler connected>
s = <Scheduler 'tcp://127.0.0.1:63906', workers: 0, cores: 0, tasks: 0>
a = <Worker 'tcp://127.0.0.1:63907', name: 0, status: closed, stored: 0, running: 0/1, ready: 0, comm: 0, waiting: 0>
b = <Worker 'tcp://127.0.0.1:63910', name: 1, status: closed, stored: 0, running: 0/2, ready: 0, comm: 0, waiting: 0>

    @gen_cluster(client=True)
    async def test_raise_on_incompatible_partitions(c, s, a, b):
        def make_partition(i):
            """Return incompatible column types for every other partition"""
            if i % 2 == 1:
                return pd.DataFrame({"a": np.random.random(10), "b": ["a"] * 10})
            return pd.DataFrame({"a": np.random.random(10), "b": np.random.random(10)})
    
        ddf = dd.from_map(make_partition, range(50))
        with dask.config.set({"dataframe.shuffle.method": "p2p"}):
            out = ddf.shuffle(on="a", ignore_index=True)
    
>       with raises_with_cause(
            RuntimeError,
            r"P2P \w* failed",
            pa.ArrowTypeError,
            "incompatible types",
        ):

distributed\shuffle\tests\test_shuffle.py:2580: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
C:\Users\runneradmin\miniconda3\envs\dask-distributed\Lib\contextlib.py:158: in __exit__
    self.gen.throw(value)
distributed\utils_test.py:2087: in raises_with_cause
    raise exc
distributed\shuffle\_core.py:574: in p2p_barrier
    return get_worker_plugin().barrier(id, run_ids)
distributed\shuffle\_worker_plugin.py:391: in barrier
    result = sync(self.worker.loop, self._barrier, shuffle_id, run_ids)
distributed\utils.py:439: in sync
    raise error
distributed\utils.py:413: in f
    result = yield future
C:\Users\runneradmin\miniconda3\envs\dask-distributed\Lib\site-packages\tornado\gen.py:766: in run
    value = future.result()
distributed\shuffle\_worker_plugin.py:365: in _barrier
    return await shuffle_run.barrier(run_ids)
distributed\shuffle\_core.py:212: in barrier
    await self.scheduler.shuffle_barrier(
distributed\core.py:1259: in send_recv_from_rpc
    return await send_recv(comm=comm, op=key, **kwargs)
distributed\core.py:1043: in send_recv
    raise exc.with_traceback(tb)
distributed\core.py:834: in _handle_comm
    result = await result
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

    from __future__ import annotations
    
    import asyncio
    import contextlib
    import itertools
    import logging
    from collections import defaultdict
    from typing import TYPE_CHECKING, Any
    
    from dask.typing import Key
    
    from distributed.core import ErrorMessage, OKMessage, error_message
    from distributed.diagnostics.plugin import SchedulerPlugin
    from distributed.metrics import time
    from distributed.protocol.pickle import dumps
    from distributed.protocol.serialize import ToPickle
    from distributed.shuffle._core import (
        P2PBarrierTask,
        RunSpecMessage,
        SchedulerShuffleState,
        ShuffleId,
        ShuffleRunSpec,
        ShuffleSpec,
        barrier_key,
        id_from_key,
    )
    from distributed.shuffle._exceptions import P2PConsistencyError, P2PIllegalStateError
    from distributed.shuffle._worker_plugin import ShuffleWorkerPlugin
    from distributed.utils import log_errors
    
    if TYPE_CHECKING:
        from distributed.scheduler import (
            Recs,
            Scheduler,
            TaskState,
            TaskStateState,
            WorkerState,
        )
    
    logger = logging.getLogger(__name__)
    
    
    class ShuffleSchedulerPlugin(SchedulerPlugin):
        """
        Shuffle plugin for the scheduler
        This coordinates the individual worker plugins to ensure correctness
        and collects heartbeat messages for the dashboard.
        See Also
        --------
        ShuffleWorkerPlugin
        """
    
        scheduler: Scheduler
        active_shuffles: dict[ShuffleId, SchedulerShuffleState]
        heartbeats: defaultdict[ShuffleId, dict]
        _shuffles: defaultdict[ShuffleId, set[SchedulerShuffleState]]
        _archived_by_stimulus: defaultdict[str, set[SchedulerShuffleState]]
        _shift_counter: itertools.count[int]
    
        def __init__(self, scheduler: Scheduler):
            self.scheduler = scheduler
            self.scheduler.handlers.update(
                {
                    "shuffle_barrier": self.barrier,
                    "shuffle_get": self.get,
                    "shuffle_get_or_create": self.get_or_create,
                    "shuffle_restrict_task": self.restrict_task,
                }
            )
            self.heartbeats = defaultdict(lambda: defaultdict(dict))
            self.active_shuffles = {}
            self.scheduler.add_plugin(self, name="shuffle")
            self._shuffles = defaultdict(set)
            self._archived_by_stimulus = defaultdict(set)
            self._shift_counter = itertools.count()
    
        async def start(self, scheduler: Scheduler) -> None:
            worker_plugin = ShuffleWorkerPlugin()
            await self.scheduler.register_worker_plugin(
                None, dumps(worker_plugin), name="shuffle", idempotent=False
            )
    
        def shuffle_ids(self) -> set[ShuffleId]:
            return set(self.active_shuffles)
    
        async def barrier(self, id: ShuffleId, run_id: int, consistent: bool) -> None:
            shuffle = self.active_shuffles[id]
            if shuffle.run_id != run_id:
                raise ValueError(f"{run_id=} does not match {shuffle}")
            if not consistent:
                logger.warning(
                    "Shuffle %s restarted due to data inconsistency during barrier",
                    shuffle.id,
                )
                return self._restart_shuffle(
                    shuffle.id,
                    self.scheduler,
                    stimulus_id=f"p2p-barrier-inconsistent-{time()}",
                )
            msg = {"op": "shuffle_inputs_done", "shuffle_id": id, "run_id": run_id}
            workers = list(shuffle.participating_workers)
            no_progress = 0
            while workers:
                res = await self.scheduler.broadcast(
                    msg=msg,
                    workers=workers,
                    on_error="return",
                )
                before = len(workers)
                workers = []
                for w, r in res.items():
                    if r is None:
                        continue
                    if isinstance(r, OSError):
                        workers.append(w)
                    else:
>                       raise RuntimeError(
                            f"Unexpected error encountered during P2P barrier: {r!r}"
                        )
E                       RuntimeError: Unexpected error encountered during P2P barrier: Exception("ArrowTypeError('Unable to merge: Field b has incompatible types: double vs large_string')")

distributed\shuffle\_scheduler_plugin.py:117: RuntimeError

Check warning on line 0 in distributed.tests.test_gc

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

1 out of 14 runs failed: test_gc_diagnosis_cpu_time (distributed.tests.test_gc) 

artifacts/windows-latest-3.10-default-notci1/pytest.xml [took 26s]
Raw output 
AssertionError: assert not 'full garbage collection released 10.75 MiB from 0 reference cycles (threshold: 9.54 MiB)\n'
 +  where 'full garbage collection released 10.75 MiB from 0 reference cycles (threshold: 9.54 MiB)\n' = <built-in method getvalue of _io.StringIO object at 0x0000019E70A2C8B0>()
 +    where <built-in method getvalue of _io.StringIO object at 0x0000019E70A2C8B0> = <_io.StringIO object at 0x0000019E70A2C8B0>.getvalue
def test_gc_diagnosis_cpu_time():
        diag = GCDiagnosis(info_over_frac=0.75)
        diag.N_SAMPLES = 3  # shorten tests
    
        with enable_gc_diagnosis_and_log(diag, level="INFO") as sio:
            # Spend some CPU time doing only full GCs
            for _ in range(diag.N_SAMPLES):
                gc.collect()
            assert not sio.getvalue()
            gc.collect()
            gc.collect()
            lines = sio.getvalue().splitlines()
            assert len(lines) == 1
            # Between 80% and 100%
            assert re.match(
                r"full garbage collections took (100|[89][0-9])% " r"CPU time recently",
                lines[0],
            )
    
        with enable_gc_diagnosis_and_log(diag, level="INFO") as sio:
            # Spend half the CPU time doing full GCs
            for _ in range(diag.N_SAMPLES + 1):
                t1 = thread_time()
                gc.collect()
                dt = thread_time() - t1
                run_for(dt, timer=thread_time)
            # Less than 75% so nothing printed
>           assert not sio.getvalue()
E           AssertionError: assert not 'full garbage collection released 10.75 MiB from 0 reference cycles (threshold: 9.54 MiB)\n'
E            +  where 'full garbage collection released 10.75 MiB from 0 reference cycles (threshold: 9.54 MiB)\n' = <built-in method getvalue of _io.StringIO object at 0x0000019E70A2C8B0>()
E            +    where <built-in method getvalue of _io.StringIO object at 0x0000019E70A2C8B0> = <_io.StringIO object at 0x0000019E70A2C8B0>.getvalue

distributed\tests\test_gc.py:120: AssertionError

Check warning on line 0 in distributed.tests.test_steal

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

1 out of 14 runs failed: test_steal_when_more_tasks (distributed.tests.test_steal) 

artifacts/windows-latest-3.10-default-ci1/pytest.xml [took 2s]
Raw output 
assert 1732620598.347897 < (1732620597.230341 + 1)
 +  where 1732620598.347897 = time()
c = <Client: No scheduler connected>
s = <Scheduler 'tcp://127.0.0.1:54279', workers: 0, cores: 0, tasks: 0>
a = <Worker 'tcp://127.0.0.1:54280', name: 0, status: closed, stored: 0, running: 1/1, ready: 0, comm: 0, waiting: 0>
rest = (<Worker 'tcp://127.0.0.1:54282', name: 1, status: closed, stored: 0, running: 0/1, ready: 0, comm: 1, waiting: 0>, <W...<Worker 'tcp://127.0.0.1:54292', name: 6, status: closed, stored: 0, running: 0/1, ready: 0, comm: 1, waiting: 0>, ...)
futures = [<Future: cancelled, type: bytes, key: slowidentity-f6250198-074c-4e20-9c99-245eba99bfe1>, <Future: cancelled, key: sl...0abe5e5-8d8c-4da2-882c-c7f5d47a9694>, <Future: cancelled, key: slowidentity-2264a82c-8e27-4d3c-bcfe-9da854a1a811>, ...]
start = 1732620597.230341, @py_assert1 = 1732620598.347897

    @gen_cluster(
        client=True,
        nthreads=[("127.0.0.1", 1)] * 10,
        worker_kwargs={"memory_limit": MEMORY_LIMIT},
        config={
            "distributed.scheduler.default-task-durations": {"slowidentity": 0.2},
            "distributed.scheduler.work-stealing-interval": "20ms",
        },
    )
    async def test_steal_when_more_tasks(c, s, a, *rest):
        x = c.submit(mul, b"0", 50000000, workers=a.address)  # 50 MB
        await wait(x)
    
        futures = [c.submit(slowidentity, x, pure=False, delay=0.2) for i in range(20)]
    
        start = time()
        while not any(w.state.tasks for w in rest):
            await asyncio.sleep(0.01)
>           assert time() < start + 1
E           assert 1732620598.347897 < (1732620597.230341 + 1)
E            +  where 1732620598.347897 = time()

distributed\tests\test_steal.py:609: AssertionError

Check notice on line 0 in .github

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

111 skipped tests found 

There are 111 skipped tests, see "Raw output" for the full list of skipped tests.
Raw output 
distributed.cli.tests.test_dask_scheduler
distributed.cli.tests.test_dask_ssh
distributed.cli.tests.test_dask_worker ‑ test_listen_address_ipv6[tcp://:---nanny]
distributed.cli.tests.test_dask_worker ‑ test_listen_address_ipv6[tcp://:---no-nanny]
distributed.cli.tests.test_dask_worker ‑ test_listen_address_ipv6[tcp://[::1]:---nanny]
distributed.cli.tests.test_dask_worker ‑ test_listen_address_ipv6[tcp://[::1]:---no-nanny]
distributed.comm.tests.test_comms ‑ test_default_client_server_ipv6[tornado]
distributed.comm.tests.test_comms ‑ test_tcp_client_server_ipv6[tornado]
distributed.comm.tests.test_comms ‑ test_tls_client_server_ipv6[tornado]
distributed.comm.tests.test_comms ‑ test_ucx_client_server
distributed.comm.tests.test_ucx
distributed.comm.tests.test_ucx_config
distributed.dashboard.tests.test_components
distributed.dashboard.tests.test_scheduler_bokeh
distributed.dashboard.tests.test_worker_bokeh
distributed.deploy.tests.test_old_ssh
distributed.deploy.tests.test_ssh
distributed.diagnostics.tests.test_cudf_diagnostics
distributed.diagnostics.tests.test_memory_sampler ‑ test_pandas[False]
distributed.diagnostics.tests.test_memory_sampler ‑ test_pandas[True]
distributed.diagnostics.tests.test_memray
distributed.diagnostics.tests.test_nvml
distributed.diagnostics.tests.test_nvml ‑ test_1_visible_devices
distributed.diagnostics.tests.test_nvml ‑ test_2_visible_devices[0,1]
distributed.diagnostics.tests.test_nvml ‑ test_2_visible_devices[1,0]
distributed.diagnostics.tests.test_nvml ‑ test_gpu_metrics
distributed.diagnostics.tests.test_nvml ‑ test_gpu_monitoring_range_query
distributed.diagnostics.tests.test_nvml ‑ test_gpu_monitoring_recent
distributed.diagnostics.tests.test_nvml ‑ test_has_cuda_context
distributed.diagnostics.tests.test_nvml ‑ test_one_time
distributed.diagnostics.tests.test_nvml ‑ test_visible_devices_bad_uuid
distributed.diagnostics.tests.test_nvml ‑ test_visible_devices_uuid
distributed.diagnostics.tests.test_nvml ‑ test_visible_devices_uuid_2[0]
distributed.diagnostics.tests.test_nvml ‑ test_visible_devices_uuid_2[1]
distributed.diagnostics.tests.test_progress_stream
distributed.diagnostics.tests.test_progress_widgets
distributed.diagnostics.tests.test_rmm_diagnostics
distributed.protocol.tests.test_arrow
distributed.protocol.tests.test_collection
distributed.protocol.tests.test_collection_cuda ‑ test_serialize_cupy[50-cuda-dict]
distributed.protocol.tests.test_collection_cuda ‑ test_serialize_cupy[50-cuda-tuple]
distributed.protocol.tests.test_collection_cuda ‑ test_serialize_cupy[None-pickle-dict]
distributed.protocol.tests.test_collection_cuda ‑ test_serialize_cupy[None-pickle-tuple]
distributed.protocol.tests.test_collection_cuda ‑ test_serialize_pandas_pandas[None-pickle-dict]
distributed.protocol.tests.test_collection_cuda ‑ test_serialize_pandas_pandas[None-pickle-tuple]
distributed.protocol.tests.test_collection_cuda ‑ test_serialize_pandas_pandas[df20-cuda-dict]
distributed.protocol.tests.test_collection_cuda ‑ test_serialize_pandas_pandas[df20-cuda-tuple]
distributed.protocol.tests.test_cupy
distributed.protocol.tests.test_h5py
distributed.protocol.tests.test_highlevelgraph
distributed.protocol.tests.test_keras
distributed.protocol.tests.test_netcdf4
distributed.protocol.tests.test_numba
distributed.protocol.tests.test_numpy
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy_custom_dtype
distributed.protocol.tests.test_pandas
distributed.protocol.tests.test_rmm
distributed.protocol.tests.test_scipy
distributed.protocol.tests.test_serialize ‑ test_check_dask_serializable[data7-True]
distributed.protocol.tests.test_sparse
distributed.protocol.tests.test_torch
distributed.shuffle.tests.test_graph
distributed.shuffle.tests.test_graph ‑ test_raise_on_custom_objects
distributed.shuffle.tests.test_merge
distributed.shuffle.tests.test_merge_column_and_index
distributed.shuffle.tests.test_rechunk
distributed.shuffle.tests.test_shuffle
distributed.shuffle.tests.test_shuffle ‑ test_basic_cudf_support
distributed.shuffle.tests.test_shuffle_plugins
distributed.tests.test_actor ‑ test_linear_access
distributed.tests.test_client ‑ test_annotations_survive_optimization
distributed.tests.test_client ‑ test_badly_serialized_input_stderr
distributed.tests.test_client ‑ test_balance_tasks_by_stacks
distributed.tests.test_client ‑ test_client_repr_closed_sync
distributed.tests.test_client ‑ test_contiguous_load
distributed.tests.test_client ‑ test_dont_hold_on_to_large_messages
distributed.tests.test_client ‑ test_interleave_computations_map
distributed.tests.test_client ‑ test_multiple_clients
distributed.tests.test_config ‑ test_uvloop_event_loop
distributed.tests.test_counter ‑ test_digest[None-<lambda>]
distributed.tests.test_dask_collections
distributed.tests.test_dask_collections ‑ test_sparse_arrays
distributed.tests.test_gc ‑ test_gc_diagnosis_rss_win
distributed.tests.test_jupyter
distributed.tests.test_metrics ‑ test_monotonic
distributed.tests.test_nanny ‑ test_nanny_closed_by_keyboard_interrupt[tcp]
distributed.tests.test_nanny ‑ test_nanny_closed_by_keyboard_interrupt[ucx]
distributed.tests.test_preload ‑ test_client_preload_click
distributed.tests.test_preload ‑ test_client_preload_text
distributed.tests.test_profile ‑ test_basic_low_level
distributed.tests.test_resources ‑ test_balance_resources
distributed.tests.test_resources ‑ test_collections_get[True]
distributed.tests.test_resources ‑ test_dont_optimize_out
distributed.tests.test_resources ‑ test_full_collections
distributed.tests.test_scheduler ‑ test_rebalance_raises_missing_data3[True]
distributed.tests.test_steal ‑ test_correct_bad_time_estimate
distributed.tests.test_steal ‑ test_steal_related_tasks
distributed.tests.test_stress ‑ test_no_delay_during_large_transfer
distributed.tests.test_stress ‑ test_stress_steal
distributed.tests.test_utils_test ‑ test_gen_cluster_cleans_up_client
distributed.tests.test_utils_test ‑ test_gen_test
distributed.tests.test_utils_test ‑ test_gen_test_legacy_explicit
distributed.tests.test_utils_test ‑ test_gen_test_legacy_implicit
distributed.tests.test_worker ‑ test_dont_overlap_communications_to_same_worker
distributed.tests.test_worker ‑ test_get_client_coroutine_sync
distributed.tests.test_worker ‑ test_protocol_from_scheduler_address[Nanny]
distributed.tests.test_worker ‑ test_protocol_from_scheduler_address[Worker]
distributed.tests.test_worker ‑ test_share_communication
distributed.tests.test_worker ‑ test_upload_file_pyc
distributed.tests.test_worker ‑ test_upload_large_file
distributed.tests.test_worker ‑ test_wait_for_outgoing

Check notice on line 0 in .github

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

4130 tests found (test 1 to 855) 

There are 4130 tests, see "Raw output" for the list of tests 1 to 855.
Raw output 
distributed.cli.tests.test_dask_scheduler
distributed.cli.tests.test_dask_scheduler ‑ test_dashboard
distributed.cli.tests.test_dask_scheduler ‑ test_dashboard_allowlist
distributed.cli.tests.test_dask_scheduler ‑ test_dashboard_non_standard_ports
distributed.cli.tests.test_dask_scheduler ‑ test_dashboard_port_zero
distributed.cli.tests.test_dask_scheduler ‑ test_defaults
distributed.cli.tests.test_dask_scheduler ‑ test_hostport
distributed.cli.tests.test_dask_scheduler ‑ test_idle_timeout
distributed.cli.tests.test_dask_scheduler ‑ test_interface
distributed.cli.tests.test_dask_scheduler ‑ test_multiple_protocols
distributed.cli.tests.test_dask_scheduler ‑ test_multiple_workers
distributed.cli.tests.test_dask_scheduler ‑ test_multiple_workers_2
distributed.cli.tests.test_dask_scheduler ‑ test_no_dashboard
distributed.cli.tests.test_dask_scheduler ‑ test_pid_file
distributed.cli.tests.test_dask_scheduler ‑ test_preload_command
distributed.cli.tests.test_dask_scheduler ‑ test_preload_command_default
distributed.cli.tests.test_dask_scheduler ‑ test_preload_config
distributed.cli.tests.test_dask_scheduler ‑ test_preload_file
distributed.cli.tests.test_dask_scheduler ‑ test_preload_module
distributed.cli.tests.test_dask_scheduler ‑ test_preload_remote_module
distributed.cli.tests.test_dask_scheduler ‑ test_restores_signal_handler
distributed.cli.tests.test_dask_scheduler ‑ test_scheduler_port_zero
distributed.cli.tests.test_dask_scheduler ‑ test_signal_handling[15]
distributed.cli.tests.test_dask_scheduler ‑ test_signal_handling[2]
distributed.cli.tests.test_dask_scheduler ‑ test_signal_handling[Signals.SIGINT]
distributed.cli.tests.test_dask_scheduler ‑ test_signal_handling[Signals.SIGTERM]
distributed.cli.tests.test_dask_scheduler ‑ test_single_executable_deprecated
distributed.cli.tests.test_dask_scheduler ‑ test_version_option
distributed.cli.tests.test_dask_spec ‑ test_errors
distributed.cli.tests.test_dask_spec ‑ test_file
distributed.cli.tests.test_dask_spec ‑ test_signal_handling_scheduler[15]
distributed.cli.tests.test_dask_spec ‑ test_signal_handling_scheduler[2]
distributed.cli.tests.test_dask_spec ‑ test_signal_handling_scheduler[Signals.SIGINT]
distributed.cli.tests.test_dask_spec ‑ test_signal_handling_scheduler[Signals.SIGTERM]
distributed.cli.tests.test_dask_spec ‑ test_signal_handling_worker[15-Nanny]
distributed.cli.tests.test_dask_spec ‑ test_signal_handling_worker[15-Worker]
distributed.cli.tests.test_dask_spec ‑ test_signal_handling_worker[2-Nanny]
distributed.cli.tests.test_dask_spec ‑ test_signal_handling_worker[2-Worker]
distributed.cli.tests.test_dask_spec ‑ test_signal_handling_worker[Signals.SIGINT-Nanny]
distributed.cli.tests.test_dask_spec ‑ test_signal_handling_worker[Signals.SIGINT-Worker]
distributed.cli.tests.test_dask_spec ‑ test_signal_handling_worker[Signals.SIGTERM-Nanny]
distributed.cli.tests.test_dask_spec ‑ test_signal_handling_worker[Signals.SIGTERM-Worker]
distributed.cli.tests.test_dask_spec ‑ test_text
distributed.cli.tests.test_dask_ssh
distributed.cli.tests.test_dask_ssh ‑ test_version_option
distributed.cli.tests.test_dask_worker ‑ test_apportion_ports[args0-expect0]
distributed.cli.tests.test_dask_worker ‑ test_apportion_ports[args1-expect1]
distributed.cli.tests.test_dask_worker ‑ test_apportion_ports[args10-expect10]
distributed.cli.tests.test_dask_worker ‑ test_apportion_ports[args11-expect11]
distributed.cli.tests.test_dask_worker ‑ test_apportion_ports[args12-expect12]
distributed.cli.tests.test_dask_worker ‑ test_apportion_ports[args13-expect13]
distributed.cli.tests.test_dask_worker ‑ test_apportion_ports[args14-expect14]
distributed.cli.tests.test_dask_worker ‑ test_apportion_ports[args15-expect15]
distributed.cli.tests.test_dask_worker ‑ test_apportion_ports[args16-expect16]
distributed.cli.tests.test_dask_worker ‑ test_apportion_ports[args17-expect17]
distributed.cli.tests.test_dask_worker ‑ test_apportion_ports[args2-expect2]
distributed.cli.tests.test_dask_worker ‑ test_apportion_ports[args3-expect3]
distributed.cli.tests.test_dask_worker ‑ test_apportion_ports[args4-expect4]
distributed.cli.tests.test_dask_worker ‑ test_apportion_ports[args5-expect5]
distributed.cli.tests.test_dask_worker ‑ test_apportion_ports[args6-expect6]
distributed.cli.tests.test_dask_worker ‑ test_apportion_ports[args7-expect7]
distributed.cli.tests.test_dask_worker ‑ test_apportion_ports[args8-expect8]
distributed.cli.tests.test_dask_worker ‑ test_apportion_ports[args9-expect9]
distributed.cli.tests.test_dask_worker ‑ test_apportion_ports_bad
distributed.cli.tests.test_dask_worker ‑ test_contact_listen_address[tcp://0.0.0.0:---nanny]
distributed.cli.tests.test_dask_worker ‑ test_contact_listen_address[tcp://0.0.0.0:---no-nanny]
distributed.cli.tests.test_dask_worker ‑ test_contact_listen_address[tcp://127.0.0.2:---nanny]
distributed.cli.tests.test_dask_worker ‑ test_contact_listen_address[tcp://127.0.0.2:---no-nanny]
distributed.cli.tests.test_dask_worker ‑ test_dashboard_non_standard_ports
distributed.cli.tests.test_dask_worker ‑ test_error_during_startup[--nanny]
distributed.cli.tests.test_dask_worker ‑ test_error_during_startup[--no-nanny]
distributed.cli.tests.test_dask_worker ‑ test_integer_names
distributed.cli.tests.test_dask_worker ‑ test_listen_address_ipv6[tcp://:---nanny]
distributed.cli.tests.test_dask_worker ‑ test_listen_address_ipv6[tcp://:---no-nanny]
distributed.cli.tests.test_dask_worker ‑ test_listen_address_ipv6[tcp://[::1]:---nanny]
distributed.cli.tests.test_dask_worker ‑ test_listen_address_ipv6[tcp://[::1]:---no-nanny]
distributed.cli.tests.test_dask_worker ‑ test_local_directory[--nanny]
distributed.cli.tests.test_dask_worker ‑ test_local_directory[--no-nanny]
distributed.cli.tests.test_dask_worker ‑ test_memory_limit
distributed.cli.tests.test_dask_worker ‑ test_nanny_worker_port_range
distributed.cli.tests.test_dask_worker ‑ test_nanny_worker_port_range_too_many_workers_raises
distributed.cli.tests.test_dask_worker ‑ test_nanny_worker_ports
distributed.cli.tests.test_dask_worker ‑ test_no_nanny
distributed.cli.tests.test_dask_worker ‑ test_nworkers_auto
distributed.cli.tests.test_dask_worker ‑ test_nworkers_expands_name
distributed.cli.tests.test_dask_worker ‑ test_nworkers_negative
distributed.cli.tests.test_dask_worker ‑ test_nworkers_requires_nanny
distributed.cli.tests.test_dask_worker ‑ test_preload_config
distributed.cli.tests.test_dask_worker ‑ test_resources
distributed.cli.tests.test_dask_worker ‑ test_respect_host_listen_address[0.0.0.0---nanny]
distributed.cli.tests.test_dask_worker ‑ test_respect_host_listen_address[0.0.0.0---no-nanny]
distributed.cli.tests.test_dask_worker ‑ test_respect_host_listen_address[127.0.0.2---nanny]
distributed.cli.tests.test_dask_worker ‑ test_respect_host_listen_address[127.0.0.2---no-nanny]
distributed.cli.tests.test_dask_worker ‑ test_scheduler_address_env
distributed.cli.tests.test_dask_worker ‑ test_scheduler_file[--nanny]
distributed.cli.tests.test_dask_worker ‑ test_scheduler_file[--no-nanny]
distributed.cli.tests.test_dask_worker ‑ test_set_lifetime_restart_via_env_var
distributed.cli.tests.test_dask_worker ‑ test_set_lifetime_stagger_via_env_var
distributed.cli.tests.test_dask_worker ‑ test_signal_handling[15---nanny]
distributed.cli.tests.test_dask_worker ‑ test_signal_handling[15---no-nanny]
distributed.cli.tests.test_dask_worker ‑ test_signal_handling[2---nanny]
distributed.cli.tests.test_dask_worker ‑ test_signal_handling[2---no-nanny]
distributed.cli.tests.test_dask_worker ‑ test_signal_handling[Signals.SIGINT---nanny]
distributed.cli.tests.test_dask_worker ‑ test_signal_handling[Signals.SIGINT---no-nanny]
distributed.cli.tests.test_dask_worker ‑ test_signal_handling[Signals.SIGTERM---nanny]
distributed.cli.tests.test_dask_worker ‑ test_signal_handling[Signals.SIGTERM---no-nanny]
distributed.cli.tests.test_dask_worker ‑ test_single_executable_deprecated
distributed.cli.tests.test_dask_worker ‑ test_single_executable_works
distributed.cli.tests.test_dask_worker ‑ test_timeout[--nanny]
distributed.cli.tests.test_dask_worker ‑ test_timeout[--no-nanny]
distributed.cli.tests.test_dask_worker ‑ test_version_option
distributed.cli.tests.test_dask_worker ‑ test_worker_class[--nanny]
distributed.cli.tests.test_dask_worker ‑ test_worker_class[--no-nanny]
distributed.cli.tests.test_dask_worker ‑ test_worker_timeout[False]
distributed.cli.tests.test_dask_worker ‑ test_worker_timeout[True]
distributed.cli.tests.test_tls_cli ‑ test_basic
distributed.cli.tests.test_tls_cli ‑ test_nanny
distributed.cli.tests.test_tls_cli ‑ test_separate_key_cert
distributed.cli.tests.test_tls_cli ‑ test_sni
distributed.cli.tests.test_tls_cli ‑ test_use_config_file
distributed.comm.tests.test_comms ‑ test_comm_closed_on_read_error[tornado]
distributed.comm.tests.test_comms ‑ test_comm_closed_on_write_error[tornado-BufferError]
distributed.comm.tests.test_comms ‑ test_comm_closed_on_write_error[tornado-CustomBase]
distributed.comm.tests.test_comms ‑ test_comm_failure_threading[tornado]
distributed.comm.tests.test_comms ‑ test_default_client_server_ipv4[tornado]
distributed.comm.tests.test_comms ‑ test_default_client_server_ipv6[tornado]
distributed.comm.tests.test_comms ‑ test_do_not_share_buffers[tornado-OpaqueList]
distributed.comm.tests.test_comms ‑ test_do_not_share_buffers[tornado-list]
distributed.comm.tests.test_comms ‑ test_get_address_host[tornado]
distributed.comm.tests.test_comms ‑ test_get_local_address_for[tornado]
distributed.comm.tests.test_comms ‑ test_get_stream_address_raises_if_closed
distributed.comm.tests.test_comms ‑ test_handshake_slow_comm[tornado]
distributed.comm.tests.test_comms ‑ test_inproc_adresses
distributed.comm.tests.test_comms ‑ test_inproc_client_server
distributed.comm.tests.test_comms ‑ test_inproc_comm_closed_explicit
distributed.comm.tests.test_comms ‑ test_inproc_comm_closed_explicit_2
distributed.comm.tests.test_comms ‑ test_inproc_comm_closed_implicit
distributed.comm.tests.test_comms ‑ test_inproc_connect_timeout
distributed.comm.tests.test_comms ‑ test_inproc_continues_listening_after_handshake_error
distributed.comm.tests.test_comms ‑ test_inproc_deserialize
distributed.comm.tests.test_comms ‑ test_inproc_deserialize_roundtrip
distributed.comm.tests.test_comms ‑ test_inproc_handshakes_concurrently
distributed.comm.tests.test_comms ‑ test_inproc_many_listeners
distributed.comm.tests.test_comms ‑ test_inproc_repr
distributed.comm.tests.test_comms ‑ test_inproc_specific_different_threads
distributed.comm.tests.test_comms ‑ test_inproc_specific_same_thread
distributed.comm.tests.test_comms ‑ test_parse_host_port[tornado]
distributed.comm.tests.test_comms ‑ test_register_backend_entrypoint
distributed.comm.tests.test_comms ‑ test_resolve_address[tornado]
distributed.comm.tests.test_comms ‑ test_retry_connect[tornado]
distributed.comm.tests.test_comms ‑ test_share_buffer_with_header[tornado-1-0-False]
distributed.comm.tests.test_comms ‑ test_share_buffer_with_header[tornado-1-1800-False]
distributed.comm.tests.test_comms ‑ test_share_buffer_with_header[tornado-1-2100-True]
distributed.comm.tests.test_comms ‑ test_share_buffer_with_header[tornado-200000-10500-True]
distributed.comm.tests.test_comms ‑ test_share_buffer_with_header[tornado-200000-9500-False]
distributed.comm.tests.test_comms ‑ test_share_buffer_with_header[tornado-350000-0-False]
distributed.comm.tests.test_comms ‑ test_tcp_adresses[tornado]
distributed.comm.tests.test_comms ‑ test_tcp_client_server_ipv4[tornado]
distributed.comm.tests.test_comms ‑ test_tcp_client_server_ipv6[tornado]
distributed.comm.tests.test_comms ‑ test_tcp_comm_closed_explicit[tornado]
distributed.comm.tests.test_comms ‑ test_tcp_comm_closed_implicit[tornado]
distributed.comm.tests.test_comms ‑ test_tcp_connect_timeout[tornado]
distributed.comm.tests.test_comms ‑ test_tcp_deserialize[tornado]
distributed.comm.tests.test_comms ‑ test_tcp_deserialize_eoferror[tornado]
distributed.comm.tests.test_comms ‑ test_tcp_deserialize_roundtrip[tornado]
distributed.comm.tests.test_comms ‑ test_tcp_listener_does_not_call_handler_on_handshake_error[tornado]
distributed.comm.tests.test_comms ‑ test_tcp_many_listeners[tornado]
distributed.comm.tests.test_comms ‑ test_tcp_repr[tornado]
distributed.comm.tests.test_comms ‑ test_tcp_specific[tornado]
distributed.comm.tests.test_comms ‑ test_tls_adresses[tornado]
distributed.comm.tests.test_comms ‑ test_tls_client_server_ipv4[tornado]
distributed.comm.tests.test_comms ‑ test_tls_client_server_ipv6[tornado]
distributed.comm.tests.test_comms ‑ test_tls_comm_closed_explicit[tornado]
distributed.comm.tests.test_comms ‑ test_tls_comm_closed_implicit[tornado]
distributed.comm.tests.test_comms ‑ test_tls_reject_certificate[tornado]
distributed.comm.tests.test_comms ‑ test_tls_repr[tornado]
distributed.comm.tests.test_comms ‑ test_tls_specific[tornado-None]
distributed.comm.tests.test_comms ‑ test_tls_specific[tornado-localhost]
distributed.comm.tests.test_comms ‑ test_ucx_client_server
distributed.comm.tests.test_comms ‑ test_unparse_host_port[tornado]
distributed.comm.tests.test_tcp ‑ test_getaddrinfo_invalid_af
distributed.comm.tests.test_ucx
distributed.comm.tests.test_ucx_config
distributed.comm.tests.test_ws ‑ test_collections
distributed.comm.tests.test_ws ‑ test_connection_made_with_extra_conn_args[ws://-False]
distributed.comm.tests.test_ws ‑ test_connection_made_with_extra_conn_args[ws://-True]
distributed.comm.tests.test_ws ‑ test_connection_made_with_extra_conn_args[wss://-False]
distributed.comm.tests.test_ws ‑ test_connection_made_with_extra_conn_args[wss://-True]
distributed.comm.tests.test_ws ‑ test_connection_made_with_sni
distributed.comm.tests.test_ws ‑ test_expect_scheduler_ssl_when_sharing_server
distributed.comm.tests.test_ws ‑ test_expect_ssl_context
distributed.comm.tests.test_ws ‑ test_http_and_comm_server[False-ws://-None-8786]
distributed.comm.tests.test_ws ‑ test_http_and_comm_server[False-ws://-None-8787]
distributed.comm.tests.test_ws ‑ test_http_and_comm_server[False-wss://-True-8786]
distributed.comm.tests.test_ws ‑ test_http_and_comm_server[False-wss://-True-8787]
distributed.comm.tests.test_ws ‑ test_http_and_comm_server[True-ws://-None-8786]
distributed.comm.tests.test_ws ‑ test_http_and_comm_server[True-ws://-None-8787]
distributed.comm.tests.test_ws ‑ test_http_and_comm_server[True-wss://-True-8786]
distributed.comm.tests.test_ws ‑ test_http_and_comm_server[True-wss://-True-8787]
distributed.comm.tests.test_ws ‑ test_large_transfer
distributed.comm.tests.test_ws ‑ test_listen_connect
distributed.comm.tests.test_ws ‑ test_listen_connect_wss
distributed.comm.tests.test_ws ‑ test_quiet_close
distributed.comm.tests.test_ws ‑ test_registered
distributed.comm.tests.test_ws ‑ test_roundtrip
distributed.comm.tests.test_ws ‑ test_ws_roundtrip
distributed.comm.tests.test_ws ‑ test_wss_roundtrip
distributed.dashboard.tests.test_bokeh ‑ test_old_import
distributed.dashboard.tests.test_components
distributed.dashboard.tests.test_components ‑ test_basic[Processing]
distributed.dashboard.tests.test_components ‑ test_profile_plot
distributed.dashboard.tests.test_components ‑ test_profile_time_plot
distributed.dashboard.tests.test_components ‑ test_profile_time_plot_disabled
distributed.dashboard.tests.test_scheduler_bokeh
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_ClusterMemory
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_CurrentLoad
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_FinePerformanceMetrics
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_FinePerformanceMetrics_no_spans
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_FinePerformanceMetrics_shuffle
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_ProcessingHistogram
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_SystemTimeseries
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_TaskGraph
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_TaskGraph_clear
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_TaskGraph_complex
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_TaskGraph_limit
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_TaskGraph_order
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_TaskGroupGraph
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_TaskGroupGraph_arrows
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_TaskProgress
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_TaskProgress_empty
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_WorkerNetworkBandwidth
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_WorkerNetworkBandwidth_metrics
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_WorkerTable
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_WorkerTable_add_and_remove_metrics
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_WorkerTable_custom_metric_overlap_with_core_metric
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_WorkerTable_custom_metrics
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_WorkerTable_different_metrics
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_WorkerTable_metrics_with_different_metric_2
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_WorkerTable_with_memory_limit_as_0
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_WorkersMemory
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_WorkersMemoryHistogram
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_aggregate_action
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_basic
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_bokeh_relative
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_compute_per_key
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_counters
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_events
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_hardware
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_hardware_endpoint
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_https_support
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_lots_of_tasks
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_memory_by_key
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_memory_color
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_prefix_bokeh
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_profile_server
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_profile_server_disabled
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_proxy_to_workers
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_root_redirect
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_shuffling
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_simple
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_stealing_events
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_task_stream
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_task_stream_clear_interval
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_task_stream_n_rectangles
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_task_stream_second_plugin
distributed.dashboard.tests.test_scheduler_bokeh ‑ test_worker_info
distributed.dashboard.tests.test_worker_bokeh
distributed.dashboard.tests.test_worker_bokeh ‑ test_CommunicatingStream
distributed.dashboard.tests.test_worker_bokeh ‑ test_basic[CommunicatingTimeSeries]
distributed.dashboard.tests.test_worker_bokeh ‑ test_basic[ExecutingTimeSeries]
distributed.dashboard.tests.test_worker_bokeh ‑ test_basic[StateTable]
distributed.dashboard.tests.test_worker_bokeh ‑ test_basic[SystemMonitor]
distributed.dashboard.tests.test_worker_bokeh ‑ test_counters
distributed.dashboard.tests.test_worker_bokeh ‑ test_prometheus
distributed.dashboard.tests.test_worker_bokeh ‑ test_routes
distributed.dashboard.tests.test_worker_bokeh ‑ test_services_kwargs
distributed.dashboard.tests.test_worker_bokeh ‑ test_simple
distributed.deploy.tests.test_adaptive ‑ test_adapt_callback_logs_error_in_scale_down
distributed.deploy.tests.test_adaptive ‑ test_adapt_cores_memory
distributed.deploy.tests.test_adaptive ‑ test_adapt_down
distributed.deploy.tests.test_adaptive ‑ test_adapt_gets_stopped_on_cluster_close
distributed.deploy.tests.test_adaptive ‑ test_adapt_logs_error_in_safe_target
distributed.deploy.tests.test_adaptive ‑ test_adapt_quickly
distributed.deploy.tests.test_adaptive ‑ test_adapt_stop_del
distributed.deploy.tests.test_adaptive ‑ test_adaptive_config
distributed.deploy.tests.test_adaptive ‑ test_adaptive_local_cluster
distributed.deploy.tests.test_adaptive ‑ test_adaptive_local_cluster_multi_workers
distributed.deploy.tests.test_adaptive ‑ test_adaptive_logs_stopping_once[False]
distributed.deploy.tests.test_adaptive ‑ test_adaptive_logs_stopping_once[True]
distributed.deploy.tests.test_adaptive ‑ test_adaptive_no_memory_limit
distributed.deploy.tests.test_adaptive ‑ test_adaptive_stopped
distributed.deploy.tests.test_adaptive ‑ test_adaptive_stops_on_cluster_status_change
distributed.deploy.tests.test_adaptive ‑ test_avoid_churn
distributed.deploy.tests.test_adaptive ‑ test_basic_no_loop
distributed.deploy.tests.test_adaptive ‑ test_interval
distributed.deploy.tests.test_adaptive ‑ test_min_max
distributed.deploy.tests.test_adaptive ‑ test_no_more_workers_than_tasks
distributed.deploy.tests.test_adaptive ‑ test_respect_average_nthreads
distributed.deploy.tests.test_adaptive ‑ test_scale_needs_to_be_awaited
distributed.deploy.tests.test_adaptive ‑ test_scale_up_large_tasks[1]
distributed.deploy.tests.test_adaptive ‑ test_scale_up_large_tasks[inf]
distributed.deploy.tests.test_adaptive ‑ test_target_duration[1]
distributed.deploy.tests.test_adaptive ‑ test_target_duration[5]
distributed.deploy.tests.test_adaptive ‑ test_update_adaptive
distributed.deploy.tests.test_adaptive ‑ test_worker_keys
distributed.deploy.tests.test_adaptive_core ‑ test_safe_target
distributed.deploy.tests.test_adaptive_core ‑ test_scale_down
distributed.deploy.tests.test_adaptive_core ‑ test_scale_up
distributed.deploy.tests.test_cluster ‑ test_cluster_wait_for_worker
distributed.deploy.tests.test_cluster ‑ test_deprecated_loop_properties
distributed.deploy.tests.test_cluster ‑ test_eq
distributed.deploy.tests.test_cluster ‑ test_exponential_backoff
distributed.deploy.tests.test_cluster ‑ test_repr
distributed.deploy.tests.test_cluster ‑ test_sync_context_manager_used_with_async_cluster
distributed.deploy.tests.test_deploy_utils ‑ test_default_process_thread_breakdown
distributed.deploy.tests.test_local ‑ test_Client_kwargs
distributed.deploy.tests.test_local ‑ test_Client_solo
distributed.deploy.tests.test_local ‑ test_Client_twice
distributed.deploy.tests.test_local ‑ test_Client_unused_kwargs_with_address
distributed.deploy.tests.test_local ‑ test_Client_unused_kwargs_with_cluster
distributed.deploy.tests.test_local ‑ test_Client_with_local
distributed.deploy.tests.test_local ‑ test_adapt
distributed.deploy.tests.test_local ‑ test_adapt_then_manual
distributed.deploy.tests.test_local ‑ test_async_with
distributed.deploy.tests.test_local ‑ test_asynchronous_property
distributed.deploy.tests.test_local ‑ test_blocks_until_full
distributed.deploy.tests.test_local ‑ test_bokeh[False]
distributed.deploy.tests.test_local ‑ test_bokeh[True]
distributed.deploy.tests.test_local ‑ test_bokeh_kwargs
distributed.deploy.tests.test_local ‑ test_capture_security[False]
distributed.deploy.tests.test_local ‑ test_capture_security[True]
distributed.deploy.tests.test_local ‑ test_cleanup
distributed.deploy.tests.test_local ‑ test_client_cluster_synchronous
distributed.deploy.tests.test_local ‑ test_client_constructor_with_temporary_security
distributed.deploy.tests.test_local ‑ test_close_twice
distributed.deploy.tests.test_local ‑ test_cluster_host_used_throughout_cluster[False-127.0.0.1]
distributed.deploy.tests.test_local ‑ test_cluster_host_used_throughout_cluster[False-None]
distributed.deploy.tests.test_local ‑ test_cluster_host_used_throughout_cluster[True-127.0.0.1]
distributed.deploy.tests.test_local ‑ test_cluster_host_used_throughout_cluster[True-None]
distributed.deploy.tests.test_local ‑ test_cluster_info_sync
distributed.deploy.tests.test_local ‑ test_cluster_info_sync_is_robust_to_network_blips
distributed.deploy.tests.test_local ‑ test_cluster_names
distributed.deploy.tests.test_local ‑ test_connect_to_closed_cluster
distributed.deploy.tests.test_local ‑ test_context_manager
distributed.deploy.tests.test_local ‑ test_cores
distributed.deploy.tests.test_local ‑ test_death_timeout_raises
distributed.deploy.tests.test_local ‑ test_defaults
distributed.deploy.tests.test_local ‑ test_defaults_2
distributed.deploy.tests.test_local ‑ test_defaults_3
distributed.deploy.tests.test_local ‑ test_defaults_4
distributed.deploy.tests.test_local ‑ test_defaults_5
distributed.deploy.tests.test_local ‑ test_defaults_6
distributed.deploy.tests.test_local ‑ test_dont_select_closed_worker
distributed.deploy.tests.test_local ‑ test_duplicate_clients
distributed.deploy.tests.test_local ‑ test_io_loop_periodic_callbacks
distributed.deploy.tests.test_local ‑ test_ipywidgets
distributed.deploy.tests.test_local ‑ test_ipywidgets_loop
distributed.deploy.tests.test_local ‑ test_local_cluster_redundant_kwarg[False]
distributed.deploy.tests.test_local ‑ test_local_cluster_redundant_kwarg[True]
distributed.deploy.tests.test_local ‑ test_local_cluster_supports_blocked_handlers
distributed.deploy.tests.test_local ‑ test_local_tls[False]
distributed.deploy.tests.test_local ‑ test_local_tls[True]
distributed.deploy.tests.test_local ‑ test_local_tls_restart
distributed.deploy.tests.test_local ‑ test_localcluster_get_client
distributed.deploy.tests.test_local ‑ test_localcluster_start_exception
distributed.deploy.tests.test_local ‑ test_logging
distributed.deploy.tests.test_local ‑ test_memory[3]
distributed.deploy.tests.test_local ‑ test_memory[None]
distributed.deploy.tests.test_local ‑ test_memory_limit_none
distributed.deploy.tests.test_local ‑ test_memory_nanny[3]
distributed.deploy.tests.test_local ‑ test_memory_nanny[None]
distributed.deploy.tests.test_local ‑ test_move_unserializable_data
distributed.deploy.tests.test_local ‑ test_no_dangling_asyncio_tasks
distributed.deploy.tests.test_local ‑ test_no_ipywidgets
distributed.deploy.tests.test_local ‑ test_no_workers
distributed.deploy.tests.test_local ‑ test_no_workers_sync
distributed.deploy.tests.test_local ‑ test_only_local_access
distributed.deploy.tests.test_local ‑ test_procs
distributed.deploy.tests.test_local ‑ test_protocol_inproc
distributed.deploy.tests.test_local ‑ test_protocol_ip
distributed.deploy.tests.test_local ‑ test_protocol_tcp
distributed.deploy.tests.test_local ‑ test_remote_access
distributed.deploy.tests.test_local ‑ test_repeated
distributed.deploy.tests.test_local ‑ test_repr[2 GiB]
distributed.deploy.tests.test_local ‑ test_repr[None]
distributed.deploy.tests.test_local ‑ test_scale
distributed.deploy.tests.test_local ‑ test_scale_memory_cores
distributed.deploy.tests.test_local ‑ test_scale_retires_workers
distributed.deploy.tests.test_local ‑ test_scale_up_and_down
distributed.deploy.tests.test_local ‑ test_silent_startup
distributed.deploy.tests.test_local ‑ test_simple
distributed.deploy.tests.test_local ‑ test_starts_up_sync
distributed.deploy.tests.test_local ‑ test_submit
distributed.deploy.tests.test_local ‑ test_threads_per_worker_set_to_0
distributed.deploy.tests.test_local ‑ test_transports_inproc
distributed.deploy.tests.test_local ‑ test_transports_tcp
distributed.deploy.tests.test_local ‑ test_transports_tcp_port
distributed.deploy.tests.test_local ‑ test_worker_class_nanny
distributed.deploy.tests.test_local ‑ test_worker_class_nanny_async
distributed.deploy.tests.test_local ‑ test_worker_class_worker
distributed.deploy.tests.test_local ‑ test_worker_params
distributed.deploy.tests.test_old_ssh
distributed.deploy.tests.test_old_ssh ‑ test_extra_kwargs_is_an_error
distributed.deploy.tests.test_old_ssh ‑ test_nprocs_attribute_is_deprecated
distributed.deploy.tests.test_old_ssh ‑ test_old_ssh_n_workers_with_nprocs_is_an_error
distributed.deploy.tests.test_old_ssh ‑ test_old_ssh_nprocs_renamed_to_n_workers
distributed.deploy.tests.test_slow_adaptive ‑ test_adaptive
distributed.deploy.tests.test_slow_adaptive ‑ test_scale_up_down
distributed.deploy.tests.test_slow_adaptive ‑ test_startup
distributed.deploy.tests.test_spec_cluster ‑ test_MultiWorker
distributed.deploy.tests.test_spec_cluster ‑ test_ProcessInterfaceValid
distributed.deploy.tests.test_spec_cluster ‑ test_adaptive_killed_worker
distributed.deploy.tests.test_spec_cluster ‑ test_bad_close
distributed.deploy.tests.test_spec_cluster ‑ test_broken_worker
distributed.deploy.tests.test_spec_cluster ‑ test_dashboard_link
distributed.deploy.tests.test_spec_cluster ‑ test_get_logs
distributed.deploy.tests.test_spec_cluster ‑ test_logs_deprecated
distributed.deploy.tests.test_spec_cluster ‑ test_loop_started_in_constructor
distributed.deploy.tests.test_spec_cluster ‑ test_nanny_port
distributed.deploy.tests.test_spec_cluster ‑ test_new_worker_spec
distributed.deploy.tests.test_spec_cluster ‑ test_repr
distributed.deploy.tests.test_spec_cluster ‑ test_restart
distributed.deploy.tests.test_spec_cluster ‑ test_run_spec
distributed.deploy.tests.test_spec_cluster ‑ test_run_spec_cluster_worker_names
distributed.deploy.tests.test_spec_cluster ‑ test_scale
distributed.deploy.tests.test_spec_cluster ‑ test_scale_cores_memory
distributed.deploy.tests.test_spec_cluster ‑ test_scheduler_info
distributed.deploy.tests.test_spec_cluster ‑ test_spec_close_clusters
distributed.deploy.tests.test_spec_cluster ‑ test_spec_process
distributed.deploy.tests.test_spec_cluster ‑ test_spec_sync
distributed.deploy.tests.test_spec_cluster ‑ test_specification
distributed.deploy.tests.test_spec_cluster ‑ test_unexpected_closed_worker
distributed.deploy.tests.test_spec_cluster ‑ test_widget
distributed.deploy.tests.test_ssh
distributed.deploy.tests.test_ssh ‑ test_basic
distributed.deploy.tests.test_ssh ‑ test_config_inherited_by_subprocess
distributed.deploy.tests.test_ssh ‑ test_keywords
distributed.deploy.tests.test_ssh ‑ test_list_of_connect_options
distributed.deploy.tests.test_ssh ‑ test_list_of_connect_options_raises
distributed.deploy.tests.test_ssh ‑ test_list_of_remote_python_raises
distributed.deploy.tests.test_ssh ‑ test_n_workers
distributed.deploy.tests.test_ssh ‑ test_nprocs_attribute_is_deprecated
distributed.deploy.tests.test_ssh ‑ test_remote_python
distributed.deploy.tests.test_ssh ‑ test_remote_python_as_dict
distributed.deploy.tests.test_ssh ‑ test_ssh_cluster_raises_if_asyncssh_not_installed
distributed.deploy.tests.test_ssh ‑ test_ssh_hosts_None
distributed.deploy.tests.test_ssh ‑ test_ssh_hosts_empty_list
distributed.deploy.tests.test_ssh ‑ test_ssh_n_workers_with_nprocs_is_an_error
distributed.deploy.tests.test_ssh ‑ test_ssh_nprocs_renamed_to_n_workers
distributed.deploy.tests.test_subprocess ‑ test_basic
distributed.deploy.tests.test_subprocess ‑ test_n_workers
distributed.deploy.tests.test_subprocess ‑ test_raise_if_scheduler_fails_to_start
distributed.deploy.tests.test_subprocess ‑ test_raise_on_windows
distributed.deploy.tests.test_subprocess ‑ test_scale_up_and_down
distributed.deploy.tests.test_subprocess ‑ test_subprocess_cluster_does_not_depend_on_logging
distributed.diagnostics.tests.test_cluster_dump_plugin ‑ test_cluster_dump_plugin
distributed.diagnostics.tests.test_cudf_diagnostics
distributed.diagnostics.tests.test_eventstream ‑ test_eventstream
distributed.diagnostics.tests.test_eventstream ‑ test_eventstream_remote
distributed.diagnostics.tests.test_graph_layout ‑ test_basic
distributed.diagnostics.tests.test_graph_layout ‑ test_construct_after_call
distributed.diagnostics.tests.test_graph_layout ‑ test_forget
distributed.diagnostics.tests.test_graph_layout ‑ test_layout_scatter
distributed.diagnostics.tests.test_graph_layout ‑ test_release_tasks
distributed.diagnostics.tests.test_graph_layout ‑ test_states
distributed.diagnostics.tests.test_graph_layout ‑ test_unique_positions
distributed.diagnostics.tests.test_install_plugin ‑ test_conda_install
distributed.diagnostics.tests.test_install_plugin ‑ test_conda_install_fails_on_returncode
distributed.diagnostics.tests.test_install_plugin ‑ test_conda_install_fails_when_conda_not_found
distributed.diagnostics.tests.test_install_plugin ‑ test_conda_install_fails_when_conda_raises
distributed.diagnostics.tests.test_install_plugin ‑ test_package_install_failing_does_not_restart_on_nanny
distributed.diagnostics.tests.test_install_plugin ‑ test_package_install_on_nanny
distributed.diagnostics.tests.test_install_plugin ‑ test_package_install_on_worker
distributed.diagnostics.tests.test_install_plugin ‑ test_package_install_restarts_on_nanny
distributed.diagnostics.tests.test_install_plugin ‑ test_pip_install
distributed.diagnostics.tests.test_install_plugin ‑ test_pip_install_fails
distributed.diagnostics.tests.test_memory_sampler ‑ test_at_least_one_sample
distributed.diagnostics.tests.test_memory_sampler ‑ test_multi_sample
distributed.diagnostics.tests.test_memory_sampler ‑ test_pandas[False]
distributed.diagnostics.tests.test_memory_sampler ‑ test_pandas[True]
distributed.diagnostics.tests.test_memory_sampler ‑ test_pandas_multiseries[False]
distributed.diagnostics.tests.test_memory_sampler ‑ test_pandas_multiseries[True]
distributed.diagnostics.tests.test_memory_sampler ‑ test_sync
distributed.diagnostics.tests.test_memray
distributed.diagnostics.tests.test_memray ‑ test_basic_integration_scheduler
distributed.diagnostics.tests.test_memray ‑ test_basic_integration_scheduler_report_args[False]
distributed.diagnostics.tests.test_memray ‑ test_basic_integration_scheduler_report_args[report_args0]
distributed.diagnostics.tests.test_memray ‑ test_basic_integration_workers[1]
distributed.diagnostics.tests.test_memray ‑ test_basic_integration_workers[False]
distributed.diagnostics.tests.test_memray ‑ test_basic_integration_workers[True]
distributed.diagnostics.tests.test_memray ‑ test_basic_integration_workers_report_args[False]
distributed.diagnostics.tests.test_memray ‑ test_basic_integration_workers_report_args[report_args0]
distributed.diagnostics.tests.test_nanny_plugin ‑ test_duck_typed_register_nanny_plugin_is_deprecated
distributed.diagnostics.tests.test_nanny_plugin ‑ test_nanny_plugin_with_broken_teardown_logs_on_close
distributed.diagnostics.tests.test_nanny_plugin ‑ test_plugin_with_broken_setup_on_new_nanny_logs
distributed.diagnostics.tests.test_nanny_plugin ‑ test_register_idempotent_plugin
distributed.diagnostics.tests.test_nanny_plugin ‑ test_register_non_idempotent_plugin
distributed.diagnostics.tests.test_nanny_plugin ‑ test_register_plugin_with_broken_setup_to_existing_nannies_raises
distributed.diagnostics.tests.test_nanny_plugin ‑ test_register_plugin_with_idempotent_keyword_is_deprecated
distributed.diagnostics.tests.test_nanny_plugin ‑ test_register_worker_plugin_is_deprecated
distributed.diagnostics.tests.test_nanny_plugin ‑ test_register_worker_plugin_typing_over_nanny_keyword
distributed.diagnostics.tests.test_nanny_plugin ‑ test_unregister_nanny_plugin_with_broken_teardown_raises
distributed.diagnostics.tests.test_nvml
distributed.diagnostics.tests.test_nvml ‑ test_1_visible_devices
distributed.diagnostics.tests.test_nvml ‑ test_2_visible_devices[0,1]
distributed.diagnostics.tests.test_nvml ‑ test_2_visible_devices[1,0]
distributed.diagnostics.tests.test_nvml ‑ test_enable_disable_nvml
distributed.diagnostics.tests.test_nvml ‑ test_gpu_metrics
distributed.diagnostics.tests.test_nvml ‑ test_gpu_monitoring_range_query
distributed.diagnostics.tests.test_nvml ‑ test_gpu_monitoring_recent
distributed.diagnostics.tests.test_nvml ‑ test_has_cuda_context
distributed.diagnostics.tests.test_nvml ‑ test_one_time
distributed.diagnostics.tests.test_nvml ‑ test_visible_devices_bad_uuid
distributed.diagnostics.tests.test_nvml ‑ test_visible_devices_uuid
distributed.diagnostics.tests.test_nvml ‑ test_visible_devices_uuid_2[0]
distributed.diagnostics.tests.test_nvml ‑ test_visible_devices_uuid_2[1]
distributed.diagnostics.tests.test_nvml ‑ test_wsl_monitoring_enabled
distributed.diagnostics.tests.test_progress ‑ test_AllProgress
distributed.diagnostics.tests.test_progress ‑ test_AllProgress_lost_key
distributed.diagnostics.tests.test_progress ‑ test_group_timing
distributed.diagnostics.tests.test_progress ‑ test_many_Progress
distributed.diagnostics.tests.test_progress ‑ test_multiprogress
distributed.diagnostics.tests.test_progress ‑ test_multiprogress_cancel
distributed.diagnostics.tests.test_progress ‑ test_multiprogress_warns
distributed.diagnostics.tests.test_progress ‑ test_multiprogress_with_prefix
distributed.diagnostics.tests.test_progress ‑ test_multiprogress_with_spans
distributed.diagnostics.tests.test_progress ‑ test_robust_to_bad_plugin
distributed.diagnostics.tests.test_progress_stream
distributed.diagnostics.tests.test_progress_stream ‑ test_progress_quads
distributed.diagnostics.tests.test_progress_stream ‑ test_progress_quads_many_functions
distributed.diagnostics.tests.test_progress_stream ‑ test_progress_quads_too_many
distributed.diagnostics.tests.test_progress_stream ‑ test_progress_stream
distributed.diagnostics.tests.test_progress_widgets
distributed.diagnostics.tests.test_progress_widgets ‑ test_fast
distributed.diagnostics.tests.test_progress_widgets ‑ test_multi_progressbar_widget
distributed.diagnostics.tests.test_progress_widgets ‑ test_multibar_complete
distributed.diagnostics.tests.test_progress_widgets ‑ test_multibar_func_warns
distributed.diagnostics.tests.test_progress_widgets ‑ test_multibar_with_spans
distributed.diagnostics.tests.test_progress_widgets ‑ test_progressbar_cancel
distributed.diagnostics.tests.test_progress_widgets ‑ test_progressbar_done
distributed.diagnostics.tests.test_progress_widgets ‑ test_progressbar_widget
distributed.diagnostics.tests.test_progress_widgets ‑ test_serializers
distributed.diagnostics.tests.test_progress_widgets ‑ test_tls
distributed.diagnostics.tests.test_progress_widgets ‑ test_values
distributed.diagnostics.tests.test_progressbar ‑ test_TextProgressBar_empty
distributed.diagnostics.tests.test_progressbar ‑ test_TextProgressBar_error
distributed.diagnostics.tests.test_progressbar ‑ test_deprecated_loop_properties
distributed.diagnostics.tests.test_progressbar ‑ test_progress_function
distributed.diagnostics.tests.test_progressbar ‑ test_progress_function_raises
distributed.diagnostics.tests.test_progressbar ‑ test_progress_function_w_kwargs
distributed.diagnostics.tests.test_progressbar ‑ test_progress_function_warns
distributed.diagnostics.tests.test_progressbar ‑ test_text_progressbar
distributed.diagnostics.tests.test_rmm_diagnostics
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_add_remove_worker
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_async_add_remove_worker
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_async_and_sync_add_remove_worker
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_closing_errors_ok
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_failing_async_add_remove_worker
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_failing_sync_add_remove_worker
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_lifecycle
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_register_idempotent_plugin
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_register_idempotent_plugins_directly
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_register_non_idempotent_plugin
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_register_non_idempotent_plugins_directly
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_register_plugin
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_register_plugin_on_scheduler
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_register_plugin_with_idempotent_keyword_is_deprecated
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_register_scheduler_plugin_deprecated
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_remove_worker_renamed_kwargs_allowed
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_remove_worker_without_kwargs_deprecated
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_scheduler_plugin_in_register_worker_plugin_overrides
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_scheduler_plugin_in_register_worker_plugin_overrides_nanny
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_simple
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_unregister_scheduler_plugin
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_unregister_scheduler_plugin_from_client
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_update_graph_hook_complex
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_update_graph_hook_simple
distributed.diagnostics.tests.test_task_stream ‑ test_TaskStreamPlugin
distributed.diagnostics.tests.test_task_stream ‑ test_client
distributed.diagnostics.tests.test_task_stream ‑ test_client_sync
distributed.diagnostics.tests.test_task_stream ‑ test_collect
distributed.diagnostics.tests.test_task_stream ‑ test_get_task_stream_plot
distributed.diagnostics.tests.test_task_stream ‑ test_get_task_stream_save
distributed.diagnostics.tests.test_task_stream ‑ test_maxlen
distributed.diagnostics.tests.test_task_stream ‑ test_no_startstops
distributed.diagnostics.tests.test_worker_plugin ‑ test_WorkerPlugin_overwrite
distributed.diagnostics.tests.test_worker_plugin ‑ test_assert_no_warning_no_overload
distributed.diagnostics.tests.test_worker_plugin ‑ test_create_on_construction
distributed.diagnostics.tests.test_worker_plugin ‑ test_create_with_client
distributed.diagnostics.tests.test_worker_plugin ‑ test_default_name
distributed.diagnostics.tests.test_worker_plugin ‑ test_dependent_tasks
distributed.diagnostics.tests.test_worker_plugin ‑ test_duck_typed_register_worker_plugin_is_deprecated
distributed.diagnostics.tests.test_worker_plugin ‑ test_empty_plugin
distributed.diagnostics.tests.test_worker_plugin ‑ test_failing_task_transitions_called
distributed.diagnostics.tests.test_worker_plugin ‑ test_normal_task_transitions_called
distributed.diagnostics.tests.test_worker_plugin ‑ test_plugin_with_broken_setup_on_new_worker_logs
distributed.diagnostics.tests.test_worker_plugin ‑ test_plugin_with_broken_teardown_logs_on_close
distributed.diagnostics.tests.test_worker_plugin ‑ test_register_idempotent_plugin
distributed.diagnostics.tests.test_worker_plugin ‑ test_register_non_idempotent_plugin
distributed.diagnostics.tests.test_worker_plugin ‑ test_register_plugin_with_broken_setup_to_existing_workers_raises
distributed.diagnostics.tests.test_worker_plugin ‑ test_register_plugin_with_idempotent_keyword_is_deprecated
distributed.diagnostics.tests.test_worker_plugin ‑ test_register_worker_plugin_is_deprecated
distributed.diagnostics.tests.test_worker_plugin ‑ test_register_worker_plugin_typing_over_nanny_keyword
distributed.diagnostics.tests.test_worker_plugin ‑ test_remove_with_client
distributed.diagnostics.tests.test_worker_plugin ‑ test_remove_with_client_raises
distributed.diagnostics.tests.test_worker_plugin ‑ test_superseding_task_transitions_called
distributed.diagnostics.tests.test_worker_plugin ‑ test_unregister_worker_plugin_with_broken_teardown_raises
distributed.http.scheduler.tests.test_missing_bokeh ‑ test_bokeh_version_too_high
distributed.http.scheduler.tests.test_missing_bokeh ‑ test_bokeh_version_too_low
distributed.http.scheduler.tests.test_missing_bokeh ‑ test_missing_bokeh
distributed.http.scheduler.tests.test_scheduler_http ‑ test_adaptive_target
distributed.http.scheduler.tests.test_scheduler_http ‑ test_allow_websocket_origin
distributed.http.scheduler.tests.test_scheduler_http ‑ test_api
distributed.http.scheduler.tests.test_scheduler_http ‑ test_api_disabled_by_default
distributed.http.scheduler.tests.test_scheduler_http ‑ test_call_stack_page["]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_call_stack_page[']
distributed.http.scheduler.tests.test_scheduler_http ‑ test_call_stack_page[(]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_call_stack_page[123]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_call_stack_page[1_0]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_call_stack_page[1_1]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_call_stack_page[[]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_call_stack_page[a b]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_call_stack_page[a+b]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_call_stack_page[key14]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_call_stack_page[key15]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_call_stack_page[key16]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_call_stack_page[key17]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_call_stack_page[key18]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_call_stack_page[key5]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_call_stack_page[key6]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_call_stack_page[key7]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_call_stack_page[key8]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_call_stack_page[x]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_check_idle
distributed.http.scheduler.tests.test_scheduler_http ‑ test_connect
distributed.http.scheduler.tests.test_scheduler_http ‑ test_eventstream
distributed.http.scheduler.tests.test_scheduler_http ‑ test_get_workers
distributed.http.scheduler.tests.test_scheduler_http ‑ test_health
distributed.http.scheduler.tests.test_scheduler_http ‑ test_metrics_when_prometheus_client_not_installed
distributed.http.scheduler.tests.test_scheduler_http ‑ test_prefix
distributed.http.scheduler.tests.test_scheduler_http ‑ test_prometheus
distributed.http.scheduler.tests.test_scheduler_http ‑ test_prometheus_collect_client_connections_totals
distributed.http.scheduler.tests.test_scheduler_http ‑ test_prometheus_collect_task_groups
distributed.http.scheduler.tests.test_scheduler_http ‑ test_prometheus_collect_task_prefix_counts
distributed.http.scheduler.tests.test_scheduler_http ‑ test_prometheus_collect_task_states
distributed.http.scheduler.tests.test_scheduler_http ‑ test_prometheus_collect_worker_states
distributed.http.scheduler.tests.test_scheduler_http ‑ test_prometheus_collect_worker_totals
distributed.http.scheduler.tests.test_scheduler_http ‑ test_retire_workers
distributed.http.scheduler.tests.test_scheduler_http ‑ test_sitemap
distributed.http.scheduler.tests.test_scheduler_http ‑ test_task_page["]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_task_page[']
distributed.http.scheduler.tests.test_scheduler_http ‑ test_task_page[(]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_task_page[123]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_task_page[1_0]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_task_page[1_1]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_task_page[[]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_task_page[a b]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_task_page[a+b]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_task_page[key14]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_task_page[key15]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_task_page[key16]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_task_page[key17]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_task_page[key18]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_task_page[key5]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_task_page[key6]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_task_page[key7]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_task_page[key8]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_task_page[x]
distributed.http.scheduler.tests.test_scheduler_http ‑ test_worker_404
distributed.http.scheduler.tests.test_semaphore_http ‑ test_prometheus
distributed.http.scheduler.tests.test_semaphore_http ‑ test_prometheus_without_semaphore_extension
distributed.http.scheduler.tests.test_stealing_http ‑ test_prometheus
distributed.http.scheduler.tests.test_stealing_http ‑ test_prometheus_collect_cost_total_by_cost_multipliers
distributed.http.scheduler.tests.test_stealing_http ‑ test_prometheus_collect_count_total_by_cost_multipliers
distributed.http.scheduler.tests.test_stealing_http ‑ test_prometheus_without_stealing_extension
distributed.http.tests.test_core ‑ test_prometheus_api_doc
distributed.http.tests.test_core ‑ test_scheduler
distributed.http.tests.test_routing ‑ test_basic
distributed.http.worker.tests.test_worker_http ‑ test_health
distributed.http.worker.tests.test_worker_http ‑ test_metrics_when_prometheus_client_not_installed
distributed.http.worker.tests.test_worker_http ‑ test_prometheus
distributed.http.worker.tests.test_worker_http ‑ test_prometheus_collect_memory_metrics
distributed.http.worker.tests.test_worker_http ‑ test_prometheus_collect_memory_metrics_bogus_sizeof
distributed.http.worker.tests.test_worker_http ‑ test_prometheus_collect_memory_metrics_spill_disabled
distributed.http.worker.tests.test_worker_http ‑ test_prometheus_collect_task_states
distributed.http.worker.tests.test_worker_http ‑ test_sitemap
distributed.protocol.tests.test_arrow
distributed.protocol.tests.test_arrow ‑ test_dumps_compression
distributed.protocol.tests.test_arrow ‑ test_roundtrip[RecordBatch]
distributed.protocol.tests.test_arrow ‑ test_roundtrip[Table]
distributed.protocol.tests.test_arrow ‑ test_scatter[RecordBatch]
distributed.protocol.tests.test_arrow ‑ test_scatter[Table]
distributed.protocol.tests.test_collection
distributed.protocol.tests.test_collection ‑ test_large_collections_serialize_simply
distributed.protocol.tests.test_collection ‑ test_nested_types
distributed.protocol.tests.test_collection ‑ test_serialize_collection[None-pickle-dict]
distributed.protocol.tests.test_collection ‑ test_serialize_collection[None-pickle-list]
distributed.protocol.tests.test_collection ‑ test_serialize_collection[None-pickle-tuple]
distributed.protocol.tests.test_collection ‑ test_serialize_collection[y0-dask-dict]
distributed.protocol.tests.test_collection ‑ test_serialize_collection[y0-dask-list]
distributed.protocol.tests.test_collection ‑ test_serialize_collection[y0-dask-tuple]
distributed.protocol.tests.test_collection ‑ test_serialize_collection[y1-pickle-dict]
distributed.protocol.tests.test_collection ‑ test_serialize_collection[y1-pickle-list]
distributed.protocol.tests.test_collection ‑ test_serialize_collection[y1-pickle-tuple]
distributed.protocol.tests.test_collection_cuda ‑ test_serialize_cupy[50-cuda-dict]
distributed.protocol.tests.test_collection_cuda ‑ test_serialize_cupy[50-cuda-tuple]
distributed.protocol.tests.test_collection_cuda ‑ test_serialize_cupy[None-pickle-dict]
distributed.protocol.tests.test_collection_cuda ‑ test_serialize_cupy[None-pickle-tuple]
distributed.protocol.tests.test_collection_cuda ‑ test_serialize_pandas_pandas[None-pickle-dict]
distributed.protocol.tests.test_collection_cuda ‑ test_serialize_pandas_pandas[None-pickle-tuple]
distributed.protocol.tests.test_collection_cuda ‑ test_serialize_pandas_pandas[df20-cuda-dict]
distributed.protocol.tests.test_collection_cuda ‑ test_serialize_pandas_pandas[df20-cuda-tuple]
distributed.protocol.tests.test_compression ‑ test_auto_compression
distributed.protocol.tests.test_compression ‑ test_compress_remote_comms
distributed.protocol.tests.test_compression ‑ test_compression_1
distributed.protocol.tests.test_compression ‑ test_compression_2
distributed.protocol.tests.test_compression ‑ test_compression_3
distributed.protocol.tests.test_compression ‑ test_compression_thread_safety[None-bytes]
distributed.protocol.tests.test_compression ‑ test_compression_thread_safety[None-memoryview]
distributed.protocol.tests.test_compression ‑ test_compression_thread_safety[lz4-bytes]
distributed.protocol.tests.test_compression ‑ test_compression_thread_safety[lz4-memoryview]
distributed.protocol.tests.test_compression ‑ test_compression_thread_safety[snappy-bytes]
distributed.protocol.tests.test_compression ‑ test_compression_thread_safety[snappy-memoryview]
distributed.protocol.tests.test_compression ‑ test_compression_thread_safety[zlib-bytes]
distributed.protocol.tests.test_compression ‑ test_compression_thread_safety[zlib-memoryview]
distributed.protocol.tests.test_compression ‑ test_compression_thread_safety[zstd-bytes]
distributed.protocol.tests.test_compression ‑ test_compression_thread_safety[zstd-memoryview]
distributed.protocol.tests.test_compression ‑ test_compression_without_deserialization
distributed.protocol.tests.test_compression ‑ test_disable_compression_on_localhost[127.0.0.1]
distributed.protocol.tests.test_compression ‑ test_disable_compression_on_localhost[None]
distributed.protocol.tests.test_compression ‑ test_disable_compression_on_localhost[localhost]
distributed.protocol.tests.test_compression ‑ test_get_compression_settings
distributed.protocol.tests.test_compression ‑ test_large_messages[None]
distributed.protocol.tests.test_compression ‑ test_large_messages[lz4]
distributed.protocol.tests.test_compression ‑ test_large_messages[snappy]
distributed.protocol.tests.test_compression ‑ test_large_messages[zlib]
distributed.protocol.tests.test_compression ‑ test_large_messages[zstd]
distributed.protocol.tests.test_compression ‑ test_loads_without_deserialization_avoids_compression
distributed.protocol.tests.test_compression ‑ test_lz4_decompression_avoids_deep_copy
distributed.protocol.tests.test_compression ‑ test_maybe_compress[None-bytes]
distributed.protocol.tests.test_compression ‑ test_maybe_compress[None-memoryview]
distributed.protocol.tests.test_compression ‑ test_maybe_compress[lz4-bytes]
distributed.protocol.tests.test_compression ‑ test_maybe_compress[lz4-memoryview]
distributed.protocol.tests.test_compression ‑ test_maybe_compress[snappy-bytes]
distributed.protocol.tests.test_compression ‑ test_maybe_compress[snappy-memoryview]
distributed.protocol.tests.test_compression ‑ test_maybe_compress[zlib-bytes]
distributed.protocol.tests.test_compression ‑ test_maybe_compress[zlib-memoryview]
distributed.protocol.tests.test_compression ‑ test_maybe_compress[zstd-bytes]
distributed.protocol.tests.test_compression ‑ test_maybe_compress[zstd-memoryview]
distributed.protocol.tests.test_compression ‑ test_maybe_compress_auto
distributed.protocol.tests.test_compression ‑ test_maybe_compress_memoryviews[None]
distributed.protocol.tests.test_compression ‑ test_maybe_compress_memoryviews[lz4]
distributed.protocol.tests.test_compression ‑ test_maybe_compress_memoryviews[snappy]
distributed.protocol.tests.test_compression ‑ test_maybe_compress_memoryviews[zlib]
distributed.protocol.tests.test_compression ‑ test_maybe_compress_memoryviews[zstd]
distributed.protocol.tests.test_compression ‑ test_maybe_compress_sample[None]
distributed.protocol.tests.test_compression ‑ test_maybe_compress_sample[lz4]
distributed.protocol.tests.test_compression ‑ test_maybe_compress_sample[snappy]
distributed.protocol.tests.test_compression ‑ test_maybe_compress_sample[zlib]
distributed.protocol.tests.test_compression ‑ test_maybe_compress_sample[zstd]
distributed.protocol.tests.test_cupy
distributed.protocol.tests.test_h5py
distributed.protocol.tests.test_h5py ‑ test_h5py_serialize
distributed.protocol.tests.test_h5py ‑ test_h5py_serialize_2
distributed.protocol.tests.test_h5py ‑ test_raise_error_on_serialize_write_permissions
distributed.protocol.tests.test_h5py ‑ test_serialize_deserialize_dataset
distributed.protocol.tests.test_h5py ‑ test_serialize_deserialize_file
distributed.protocol.tests.test_h5py ‑ test_serialize_deserialize_group
distributed.protocol.tests.test_highlevelgraph
distributed.protocol.tests.test_highlevelgraph ‑ test_array_annotations
distributed.protocol.tests.test_highlevelgraph ‑ test_blockwise
distributed.protocol.tests.test_highlevelgraph ‑ test_combo_of_layer_types
distributed.protocol.tests.test_highlevelgraph ‑ test_dataframe_annotations
distributed.protocol.tests.test_highlevelgraph ‑ test_shuffle
distributed.protocol.tests.test_keras
distributed.protocol.tests.test_netcdf4
distributed.protocol.tests.test_netcdf4 ‑ test_netcdf4_serialize
distributed.protocol.tests.test_netcdf4 ‑ test_serialize_deserialize_dataset
distributed.protocol.tests.test_netcdf4 ‑ test_serialize_deserialize_group
distributed.protocol.tests.test_netcdf4 ‑ test_serialize_deserialize_variable
distributed.protocol.tests.test_numba
distributed.protocol.tests.test_numpy
distributed.protocol.tests.test_numpy ‑ test_compress_memoryview
distributed.protocol.tests.test_numpy ‑ test_compress_numpy
distributed.protocol.tests.test_numpy ‑ test_dumps_large
distributed.protocol.tests.test_numpy ‑ test_dumps_numpy_writable[False]
distributed.protocol.tests.test_numpy ‑ test_dumps_numpy_writable[True]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x0]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x10]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x11]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x12]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x13]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x14]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x15]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x16]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x17]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x18]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x19]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x1]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x20]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x21]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x22]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x23]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x24]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x25]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x26]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x27]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x28]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x29]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x2]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x30]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x31]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x32]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x33]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x34]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x35]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x36]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x3]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x4]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x5]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x6]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x7]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x8]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy[x9]
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy_custom_dtype
distributed.protocol.tests.test_numpy ‑ test_dumps_serialize_numpy_large
distributed.protocol.tests.test_numpy ‑ test_itemsize[M8[s]-8]
distributed.protocol.tests.test_numpy ‑ test_itemsize[M8[us]-8]
distributed.protocol.tests.test_numpy ‑ test_itemsize[S3-3]
distributed.protocol.tests.test_numpy ‑ test_itemsize[U3-12]
distributed.protocol.tests.test_numpy ‑ test_itemsize[b-1]
distributed.protocol.tests.test_numpy ‑ test_itemsize[c16-16]
distributed.protocol.tests.test_numpy ‑ test_itemsize[dt10-8]
distributed.protocol.tests.test_numpy ‑ test_itemsize[dt11-88]
distributed.protocol.tests.test_numpy ‑ test_itemsize[dt12-8]
distributed.protocol.tests.test_numpy ‑ test_itemsize[dt8-12]
distributed.protocol.tests.test_numpy ‑ test_itemsize[dt9-4]
distributed.protocol.tests.test_numpy ‑ test_itemsize[f8-8]
distributed.protocol.tests.test_numpy ‑ test_itemsize[i4-4]
distributed.protocol.tests.test_numpy ‑ test_memmap
distributed.protocol.tests.test_numpy ‑ test_non_zero_strided_array
distributed.protocol.tests.test_numpy ‑ test_serialize
distributed.protocol.tests.test_numpy ‑ test_serialize_numpy_ma_masked
distributed.protocol.tests.test_numpy ‑ test_serialize_numpy_ma_masked_array[x0]
distributed.protocol.tests.test_numpy ‑ test_serialize_numpy_ma_masked_array[x1]
distributed.protocol.tests.test_numpy ‑ test_serialize_numpy_ma_masked_array[x2]
distributed.protocol.tests.test_numpy ‑ test_serialize_numpy_ma_masked_array[x3]
distributed.protocol.tests.test_numpy ‑ test_serialize_numpy_ma_masked_array[x4]
distributed.protocol.tests.test_numpy ‑ test_serialize_numpy_ma_masked_array[x5]
distributed.protocol.tests.test_numpy ‑ test_serialize_writeable_array_readonly_base_object
distributed.protocol.tests.test_numpy ‑ test_zero_strided_numpy_array[False-x0]
distributed.protocol.tests.test_numpy ‑ test_zero_strided_numpy_array[False-x1]
distributed.protocol.tests.test_numpy ‑ test_zero_strided_numpy_array[False-x2]
distributed.protocol.tests.test_numpy ‑ test_zero_strided_numpy_array[False-x3]
distributed.protocol.tests.test_numpy ‑ test_zero_strided_numpy_array[True-x0]

Check notice on line 0 in .github

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

4130 tests found (test 856 to 1654) 

There are 4130 tests, see "Raw output" for the list of tests 856 to 1654.
Raw output 
distributed.protocol.tests.test_numpy ‑ test_zero_strided_numpy_array[True-x1]
distributed.protocol.tests.test_numpy ‑ test_zero_strided_numpy_array[True-x2]
distributed.protocol.tests.test_numpy ‑ test_zero_strided_numpy_array[True-x3]
distributed.protocol.tests.test_pandas
distributed.protocol.tests.test_pandas ‑ test_dumps_pandas_writable
distributed.protocol.tests.test_pandas ‑ test_dumps_serialize_pandas[df0]
distributed.protocol.tests.test_pandas ‑ test_dumps_serialize_pandas[df10]
distributed.protocol.tests.test_pandas ‑ test_dumps_serialize_pandas[df11]
distributed.protocol.tests.test_pandas ‑ test_dumps_serialize_pandas[df12]
distributed.protocol.tests.test_pandas ‑ test_dumps_serialize_pandas[df13]
distributed.protocol.tests.test_pandas ‑ test_dumps_serialize_pandas[df14]
distributed.protocol.tests.test_pandas ‑ test_dumps_serialize_pandas[df15]
distributed.protocol.tests.test_pandas ‑ test_dumps_serialize_pandas[df16]
distributed.protocol.tests.test_pandas ‑ test_dumps_serialize_pandas[df17]
distributed.protocol.tests.test_pandas ‑ test_dumps_serialize_pandas[df18]
distributed.protocol.tests.test_pandas ‑ test_dumps_serialize_pandas[df19]
distributed.protocol.tests.test_pandas ‑ test_dumps_serialize_pandas[df1]
distributed.protocol.tests.test_pandas ‑ test_dumps_serialize_pandas[df20]
distributed.protocol.tests.test_pandas ‑ test_dumps_serialize_pandas[df21]
distributed.protocol.tests.test_pandas ‑ test_dumps_serialize_pandas[df22]
distributed.protocol.tests.test_pandas ‑ test_dumps_serialize_pandas[df23]
distributed.protocol.tests.test_pandas ‑ test_dumps_serialize_pandas[df24]
distributed.protocol.tests.test_pandas ‑ test_dumps_serialize_pandas[df25]
distributed.protocol.tests.test_pandas ‑ test_dumps_serialize_pandas[df2]
distributed.protocol.tests.test_pandas ‑ test_dumps_serialize_pandas[df3]
distributed.protocol.tests.test_pandas ‑ test_dumps_serialize_pandas[df4]
distributed.protocol.tests.test_pandas ‑ test_dumps_serialize_pandas[df5]
distributed.protocol.tests.test_pandas ‑ test_dumps_serialize_pandas[df6]
distributed.protocol.tests.test_pandas ‑ test_dumps_serialize_pandas[df7]
distributed.protocol.tests.test_pandas ‑ test_dumps_serialize_pandas[df8]
distributed.protocol.tests.test_pandas ‑ test_dumps_serialize_pandas[df9]
distributed.protocol.tests.test_pickle ‑ test_allow_pickle_if_registered_in_dask_serialize
distributed.protocol.tests.test_pickle ‑ test_nopickle_nested
distributed.protocol.tests.test_pickle ‑ test_pickle_by_value_when_registered
distributed.protocol.tests.test_pickle ‑ test_pickle_data[4]
distributed.protocol.tests.test_pickle ‑ test_pickle_data[5]
distributed.protocol.tests.test_pickle ‑ test_pickle_empty[4]
distributed.protocol.tests.test_pickle ‑ test_pickle_empty[5]
distributed.protocol.tests.test_pickle ‑ test_pickle_functions[4]
distributed.protocol.tests.test_pickle ‑ test_pickle_functions[5]
distributed.protocol.tests.test_pickle ‑ test_pickle_functions_in_main
distributed.protocol.tests.test_pickle ‑ test_pickle_numpy[4]
distributed.protocol.tests.test_pickle ‑ test_pickle_numpy[5]
distributed.protocol.tests.test_pickle ‑ test_pickle_out_of_band[4]
distributed.protocol.tests.test_pickle ‑ test_pickle_out_of_band[5]
distributed.protocol.tests.test_pickle ‑ test_pickle_zero_copy_read_only_flag[dask]
distributed.protocol.tests.test_pickle ‑ test_pickle_zero_copy_read_only_flag[pickle]
distributed.protocol.tests.test_protocol ‑ test_deeply_nested_structures
distributed.protocol.tests.test_protocol ‑ test_dumps_loads_Serialize
distributed.protocol.tests.test_protocol ‑ test_dumps_loads_Serialized
distributed.protocol.tests.test_protocol ‑ test_fallback_to_pickle
distributed.protocol.tests.test_protocol ‑ test_large_bytes[bytes]
distributed.protocol.tests.test_protocol ‑ test_large_bytes[memoryview]
distributed.protocol.tests.test_protocol ‑ test_large_messages_map
distributed.protocol.tests.test_protocol ‑ test_large_payload[bytes]
distributed.protocol.tests.test_protocol ‑ test_large_payload[ext]
distributed.protocol.tests.test_protocol ‑ test_large_payload[str]
distributed.protocol.tests.test_protocol ‑ test_loads_deserialize_False
distributed.protocol.tests.test_protocol ‑ test_preserve_header[serializers0]
distributed.protocol.tests.test_protocol ‑ test_preserve_header[serializers1]
distributed.protocol.tests.test_protocol ‑ test_protocol
distributed.protocol.tests.test_protocol ‑ test_sizeof_serialize[Serialize-Serialized0]
distributed.protocol.tests.test_protocol ‑ test_sizeof_serialize[Serialize-Serialized1]
distributed.protocol.tests.test_protocol ‑ test_sizeof_serialize[ToPickle-Pickled]
distributed.protocol.tests.test_protocol ‑ test_small
distributed.protocol.tests.test_protocol ‑ test_small_and_big
distributed.protocol.tests.test_protocol_utils ‑ test_pack_frames
distributed.protocol.tests.test_protocol_utils ‑ test_unpack_frames_partial
distributed.protocol.tests.test_protocol_utils ‑ test_unpack_frames_remainder[456]
distributed.protocol.tests.test_protocol_utils ‑ test_unpack_frames_remainder[]
distributed.protocol.tests.test_protocol_utils.TestMergeMemroyviews ‑ test_catch_different_buffer
distributed.protocol.tests.test_protocol_utils.TestMergeMemroyviews ‑ test_catch_different_formats
distributed.protocol.tests.test_protocol_utils.TestMergeMemroyviews ‑ test_catch_different_non_contiguous
distributed.protocol.tests.test_protocol_utils.TestMergeMemroyviews ‑ test_catch_gaps[slices0]
distributed.protocol.tests.test_protocol_utils.TestMergeMemroyviews ‑ test_catch_gaps[slices1]
distributed.protocol.tests.test_protocol_utils.TestMergeMemroyviews ‑ test_catch_gaps[slices2]
distributed.protocol.tests.test_protocol_utils.TestMergeMemroyviews ‑ test_catch_multidimensional
distributed.protocol.tests.test_protocol_utils.TestMergeMemroyviews ‑ test_catch_non_memoryview
distributed.protocol.tests.test_protocol_utils.TestMergeMemroyviews ‑ test_empty
distributed.protocol.tests.test_protocol_utils.TestMergeMemroyviews ‑ test_one
distributed.protocol.tests.test_protocol_utils.TestMergeMemroyviews ‑ test_parts[slices0]
distributed.protocol.tests.test_protocol_utils.TestMergeMemroyviews ‑ test_parts[slices1]
distributed.protocol.tests.test_protocol_utils.TestMergeMemroyviews ‑ test_parts[slices2]
distributed.protocol.tests.test_protocol_utils.TestMergeMemroyviews ‑ test_parts[slices3]
distributed.protocol.tests.test_protocol_utils.TestMergeMemroyviews ‑ test_parts[slices4]
distributed.protocol.tests.test_protocol_utils.TestMergeMemroyviews ‑ test_parts[slices5]
distributed.protocol.tests.test_protocol_utils.TestMergeMemroyviews ‑ test_parts[slices6]
distributed.protocol.tests.test_protocol_utils.TestMergeMemroyviews ‑ test_parts[slices7]
distributed.protocol.tests.test_protocol_utils.TestMergeMemroyviews ‑ test_parts[slices8]
distributed.protocol.tests.test_protocol_utils.TestMergeMemroyviews ‑ test_parts[slices9]
distributed.protocol.tests.test_protocol_utils.TestMergeMemroyviews ‑ test_readonly_buffer
distributed.protocol.tests.test_rmm
distributed.protocol.tests.test_scipy
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype0-bsr_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype0-coo_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype0-csc_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype0-csr_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype0-dia_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype0-dok_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype0-lil_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype1-bsr_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype1-coo_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype1-csc_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype1-csr_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype1-dia_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype1-dok_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype1-lil_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype2-bsr_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype2-coo_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype2-csc_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype2-csr_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype2-dia_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype2-dok_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype2-lil_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype3-bsr_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype3-coo_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype3-csc_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype3-csr_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype3-dia_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype3-dok_matrix]
distributed.protocol.tests.test_scipy ‑ test_serialize_scipy_sparse[dtype3-lil_matrix]
distributed.protocol.tests.test_serialize ‑ test_Serialize
distributed.protocol.tests.test_serialize ‑ test_Serialized
distributed.protocol.tests.test_serialize ‑ test__is_msgpack_serializable
distributed.protocol.tests.test_serialize ‑ test_check_dask_serializable[data0-False]
distributed.protocol.tests.test_serialize ‑ test_check_dask_serializable[data1-False]
distributed.protocol.tests.test_serialize ‑ test_check_dask_serializable[data10-True]
distributed.protocol.tests.test_serialize ‑ test_check_dask_serializable[data11-True]
distributed.protocol.tests.test_serialize ‑ test_check_dask_serializable[data12-True]
distributed.protocol.tests.test_serialize ‑ test_check_dask_serializable[data2-False]
distributed.protocol.tests.test_serialize ‑ test_check_dask_serializable[data3-False]
distributed.protocol.tests.test_serialize ‑ test_check_dask_serializable[data4-False]
distributed.protocol.tests.test_serialize ‑ test_check_dask_serializable[data5-True]
distributed.protocol.tests.test_serialize ‑ test_check_dask_serializable[data6-True]
distributed.protocol.tests.test_serialize ‑ test_check_dask_serializable[data7-True]
distributed.protocol.tests.test_serialize ‑ test_check_dask_serializable[data8-True]
distributed.protocol.tests.test_serialize ‑ test_check_dask_serializable[data9-True]
distributed.protocol.tests.test_serialize ‑ test_context_specific_serialization
distributed.protocol.tests.test_serialize ‑ test_context_specific_serialization_class
distributed.protocol.tests.test_serialize ‑ test_deeply_nested_structures[100]
distributed.protocol.tests.test_serialize ‑ test_deeply_nested_structures[150]
distributed.protocol.tests.test_serialize ‑ test_deeply_nested_structures[200]
distributed.protocol.tests.test_serialize ‑ test_deeply_nested_structures[250]
distributed.protocol.tests.test_serialize ‑ test_deeply_nested_structures[300]
distributed.protocol.tests.test_serialize ‑ test_deeply_nested_structures[350]
distributed.protocol.tests.test_serialize ‑ test_deeply_nested_structures[400]
distributed.protocol.tests.test_serialize ‑ test_deeply_nested_structures[450]
distributed.protocol.tests.test_serialize ‑ test_deeply_nested_structures[500]
distributed.protocol.tests.test_serialize ‑ test_deeply_nested_structures[550]
distributed.protocol.tests.test_serialize ‑ test_deser_memoryview[data_in0]
distributed.protocol.tests.test_serialize ‑ test_deser_memoryview[data_in1]
distributed.protocol.tests.test_serialize ‑ test_deserialize_bytes_zero_copy_read_only
distributed.protocol.tests.test_serialize ‑ test_deserialize_bytes_zero_copy_writeable
distributed.protocol.tests.test_serialize ‑ test_different_compression_families
distributed.protocol.tests.test_serialize ‑ test_dumps_serialize
distributed.protocol.tests.test_serialize ‑ test_empty
distributed.protocol.tests.test_serialize ‑ test_empty_loads
distributed.protocol.tests.test_serialize ‑ test_empty_loads_deep
distributed.protocol.tests.test_serialize ‑ test_err_on_bad_deserializer
distributed.protocol.tests.test_serialize ‑ test_errors
distributed.protocol.tests.test_serialize ‑ test_frame_split
distributed.protocol.tests.test_serialize ‑ test_inter_worker_comms
distributed.protocol.tests.test_serialize ‑ test_large_pickled_object
distributed.protocol.tests.test_serialize ‑ test_malicious_exception
distributed.protocol.tests.test_serialize ‑ test_nested_deserialize
distributed.protocol.tests.test_serialize ‑ test_object_in_graph
distributed.protocol.tests.test_serialize ‑ test_scatter
distributed.protocol.tests.test_serialize ‑ test_ser_empty_1d_memoryview
distributed.protocol.tests.test_serialize ‑ test_ser_empty_nd_memoryview
distributed.protocol.tests.test_serialize ‑ test_ser_memoryview_object
distributed.protocol.tests.test_serialize ‑ test_serialize_arrays[B]
distributed.protocol.tests.test_serialize ‑ test_serialize_arrays[H]
distributed.protocol.tests.test_serialize ‑ test_serialize_arrays[I]
distributed.protocol.tests.test_serialize ‑ test_serialize_arrays[L]
distributed.protocol.tests.test_serialize ‑ test_serialize_arrays[Q]
distributed.protocol.tests.test_serialize ‑ test_serialize_arrays[b]
distributed.protocol.tests.test_serialize ‑ test_serialize_arrays[d]
distributed.protocol.tests.test_serialize ‑ test_serialize_arrays[f]
distributed.protocol.tests.test_serialize ‑ test_serialize_arrays[h]
distributed.protocol.tests.test_serialize ‑ test_serialize_arrays[i]
distributed.protocol.tests.test_serialize ‑ test_serialize_arrays[l]
distributed.protocol.tests.test_serialize ‑ test_serialize_arrays[q]
distributed.protocol.tests.test_serialize ‑ test_serialize_bytes[kwargs0]
distributed.protocol.tests.test_serialize ‑ test_serialize_bytes[kwargs1]
distributed.protocol.tests.test_serialize ‑ test_serialize_bytes_numpy[kwargs0]
distributed.protocol.tests.test_serialize ‑ test_serialize_bytes_numpy[kwargs1]
distributed.protocol.tests.test_serialize ‑ test_serialize_bytestrings
distributed.protocol.tests.test_serialize ‑ test_serialize_empty_array
distributed.protocol.tests.test_serialize ‑ test_serialize_iterate_collection
distributed.protocol.tests.test_serialize ‑ test_serialize_list_compress
distributed.protocol.tests.test_serialize ‑ test_serialize_lists[serializers0]
distributed.protocol.tests.test_serialize ‑ test_serialize_lists[serializers1]
distributed.protocol.tests.test_serialize ‑ test_serialize_lists[serializers2]
distributed.protocol.tests.test_serialize ‑ test_serialize_lists[serializers3]
distributed.protocol.tests.test_serialize ‑ test_serialize_raises
distributed.protocol.tests.test_sparse
distributed.protocol.tests.test_to_pickle ‑ test_ToPickle
distributed.protocol.tests.test_torch
distributed.protocol.tests.test_torch ‑ test_deserialize_grad
distributed.protocol.tests.test_torch ‑ test_grad[False]
distributed.protocol.tests.test_torch ‑ test_grad[True]
distributed.protocol.tests.test_torch ‑ test_resnet
distributed.protocol.tests.test_torch ‑ test_tensor
distributed.protocol.tests.test_utils ‑ test_host_array
distributed.protocol.tests.test_utils ‑ test_host_array_from_buffers
distributed.protocol.tests.test_utils ‑ test_host_array_from_buffers_numpy
distributed.protocol.tests.test_utils_test ‑ test_get_host_array
distributed.shuffle.tests.test_buffer ‑ test_memory_limit[big_payloads0]
distributed.shuffle.tests.test_buffer ‑ test_memory_limit[big_payloads1]
distributed.shuffle.tests.test_buffer ‑ test_memory_limit[big_payloads2]
distributed.shuffle.tests.test_buffer ‑ test_memory_limit[big_payloads3]
distributed.shuffle.tests.test_buffer ‑ test_memory_limit_blocked_exception
distributed.shuffle.tests.test_comm_buffer ‑ test_basic
distributed.shuffle.tests.test_comm_buffer ‑ test_concurrent_puts
distributed.shuffle.tests.test_comm_buffer ‑ test_concurrent_puts_error
distributed.shuffle.tests.test_comm_buffer ‑ test_exceptions
distributed.shuffle.tests.test_comm_buffer ‑ test_slow_send
distributed.shuffle.tests.test_core ‑ test_mean_shard_size
distributed.shuffle.tests.test_core ‑ test_mean_shard_size_numpy
distributed.shuffle.tests.test_disk_buffer ‑ test_basic
distributed.shuffle.tests.test_disk_buffer ‑ test_exceptions
distributed.shuffle.tests.test_disk_buffer ‑ test_high_pressure_flush_with_exception
distributed.shuffle.tests.test_disk_buffer ‑ test_many[1000]
distributed.shuffle.tests.test_disk_buffer ‑ test_many[100]
distributed.shuffle.tests.test_disk_buffer ‑ test_many[2]
distributed.shuffle.tests.test_disk_buffer ‑ test_read_before_flush
distributed.shuffle.tests.test_graph
distributed.shuffle.tests.test_graph ‑ test_basic
distributed.shuffle.tests.test_graph ‑ test_basic_state
distributed.shuffle.tests.test_graph ‑ test_does_not_raise_on_stringified_numeric_column_name
distributed.shuffle.tests.test_graph ‑ test_multiple_linear
distributed.shuffle.tests.test_graph ‑ test_raise_on_complex_numbers[cdouble]
distributed.shuffle.tests.test_graph ‑ test_raise_on_complex_numbers[clongdouble]
distributed.shuffle.tests.test_graph ‑ test_raise_on_complex_numbers[csingle]
distributed.shuffle.tests.test_graph ‑ test_raise_on_custom_objects
distributed.shuffle.tests.test_graph ‑ test_raise_on_non_string_column_name
distributed.shuffle.tests.test_graph ‑ test_raise_on_sparse_data
distributed.shuffle.tests.test_limiter ‑ test_limiter_basic
distributed.shuffle.tests.test_limiter ‑ test_limiter_concurrent_decrease_releases_waiter
distributed.shuffle.tests.test_limiter ‑ test_limiter_no_limit_no_statistics
distributed.shuffle.tests.test_limiter ‑ test_limiter_statistics
distributed.shuffle.tests.test_limiter ‑ test_unlimited_limiter
distributed.shuffle.tests.test_memory_buffer ‑ test_basic
distributed.shuffle.tests.test_memory_buffer ‑ test_many[1000]
distributed.shuffle.tests.test_memory_buffer ‑ test_many[100]
distributed.shuffle.tests.test_memory_buffer ‑ test_many[2]
distributed.shuffle.tests.test_memory_buffer ‑ test_read_before_flush
distributed.shuffle.tests.test_merge
distributed.shuffle.tests.test_merge ‑ test_basic_merge[inner]
distributed.shuffle.tests.test_merge ‑ test_basic_merge[left]
distributed.shuffle.tests.test_merge ‑ test_basic_merge[outer]
distributed.shuffle.tests.test_merge ‑ test_basic_merge[right]
distributed.shuffle.tests.test_merge ‑ test_index_merge_p2p[inner]
distributed.shuffle.tests.test_merge ‑ test_index_merge_p2p[left]
distributed.shuffle.tests.test_merge ‑ test_index_merge_p2p[outer]
distributed.shuffle.tests.test_merge ‑ test_index_merge_p2p[right]
distributed.shuffle.tests.test_merge ‑ test_merge[False-inner]
distributed.shuffle.tests.test_merge ‑ test_merge[False-left]
distributed.shuffle.tests.test_merge ‑ test_merge[False-outer]
distributed.shuffle.tests.test_merge ‑ test_merge[False-right]
distributed.shuffle.tests.test_merge ‑ test_merge[True-inner]
distributed.shuffle.tests.test_merge ‑ test_merge[True-left]
distributed.shuffle.tests.test_merge ‑ test_merge[True-outer]
distributed.shuffle.tests.test_merge ‑ test_merge[True-right]
distributed.shuffle.tests.test_merge ‑ test_merge_by_multiple_columns[inner]
distributed.shuffle.tests.test_merge ‑ test_merge_by_multiple_columns[left]
distributed.shuffle.tests.test_merge ‑ test_merge_by_multiple_columns[outer]
distributed.shuffle.tests.test_merge ‑ test_merge_by_multiple_columns[right]
distributed.shuffle.tests.test_merge ‑ test_merge_does_not_deadlock_if_worker_joins
distributed.shuffle.tests.test_merge ‑ test_merge_indicator
distributed.shuffle.tests.test_merge ‑ test_merge_p2p_shuffle_reused_dataframe_with_different_parameters
distributed.shuffle.tests.test_merge ‑ test_merge_p2p_shuffle_reused_dataframe_with_same_parameters
distributed.shuffle.tests.test_merge ‑ test_merge_with_npartitions[10]
distributed.shuffle.tests.test_merge ‑ test_merge_with_npartitions[20]
distributed.shuffle.tests.test_merge ‑ test_merge_with_npartitions[4]
distributed.shuffle.tests.test_merge ‑ test_merge_with_npartitions[5]
distributed.shuffle.tests.test_merge ‑ test_minimal_version
distributed.shuffle.tests.test_merge_column_and_index
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_known_to_unknown[idx-inner]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_known_to_unknown[idx-left]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_known_to_unknown[idx-outer]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_known_to_unknown[idx-right]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_known_to_unknown[on1-inner]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_known_to_unknown[on1-left]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_known_to_unknown[on1-outer]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_known_to_unknown[on1-right]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_known_to_unknown[on2-inner]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_known_to_unknown[on2-left]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_known_to_unknown[on2-outer]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_known_to_unknown[on2-right]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_known_to_unknown[on3-inner]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_known_to_unknown[on3-left]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_known_to_unknown[on3-outer]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_known_to_unknown[on3-right]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_known[idx-inner]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_known[idx-left]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_known[idx-outer]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_known[idx-right]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_known[on1-inner]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_known[on1-left]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_known[on1-outer]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_known[on1-right]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_known[on2-inner]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_known[on2-left]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_known[on2-outer]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_known[on2-right]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_known[on3-inner]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_known[on3-left]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_known[on3-outer]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_known[on3-right]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_unknown[idx-inner]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_unknown[idx-left]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_unknown[idx-outer]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_unknown[idx-right]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_unknown[on1-inner]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_unknown[on1-left]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_unknown[on1-outer]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_unknown[on1-right]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_unknown[on2-inner]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_unknown[on2-left]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_unknown[on2-outer]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_unknown[on2-right]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_unknown[on3-inner]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_unknown[on3-left]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_unknown[on3-outer]
distributed.shuffle.tests.test_merge_column_and_index ‑ test_merge_unknown_to_unknown[on3-right]
distributed.shuffle.tests.test_metrics ‑ test_dataframe
distributed.shuffle.tests.test_metrics ‑ test_rechunk
distributed.shuffle.tests.test_pickle ‑ test_pickle
distributed.shuffle.tests.test_pickle ‑ test_pickle_numpy
distributed.shuffle.tests.test_pickle ‑ test_pickle_zero_copy
distributed.shuffle.tests.test_read_write_lock ‑ test_basic
distributed.shuffle.tests.test_read_write_lock ‑ test_concurrent_reads_are_allowed
distributed.shuffle.tests.test_read_write_lock ‑ test_lock_timeout
distributed.shuffle.tests.test_read_write_lock ‑ test_read_blocks_write
distributed.shuffle.tests.test_read_write_lock ‑ test_write_blocks_read
distributed.shuffle.tests.test_read_write_lock ‑ test_write_blocks_write
distributed.shuffle.tests.test_read_write_lock ‑ test_write_preferred_over_read
distributed.shuffle.tests.test_rechunk
distributed.shuffle.tests.test_rechunk ‑ test_calculate_prechunking_1d[old0-new0-expected0]
distributed.shuffle.tests.test_rechunk ‑ test_calculate_prechunking_1d[old1-new1-expected1]
distributed.shuffle.tests.test_rechunk ‑ test_calculate_prechunking_1d[old2-new2-expected2]
distributed.shuffle.tests.test_rechunk ‑ test_calculate_prechunking_1d[old3-new3-expected3]
distributed.shuffle.tests.test_rechunk ‑ test_calculate_prechunking_1d[old4-new4-expected4]
distributed.shuffle.tests.test_rechunk ‑ test_calculate_prechunking_2d[old0-new0-expected0]
distributed.shuffle.tests.test_rechunk ‑ test_calculate_prechunking_2d[old1-new1-expected1]
distributed.shuffle.tests.test_rechunk ‑ test_calculate_prechunking_2d[old2-new2-expected2]
distributed.shuffle.tests.test_rechunk ‑ test_calculate_prechunking_2d[old3-new3-expected3]
distributed.shuffle.tests.test_rechunk ‑ test_calculate_prechunking_2d[old4-new4-expected4]
distributed.shuffle.tests.test_rechunk ‑ test_calculate_prechunking_2d[old5-new5-expected5]
distributed.shuffle.tests.test_rechunk ‑ test_calculate_prechunking_3d[old0-new0-expected0]
distributed.shuffle.tests.test_rechunk ‑ test_calculate_prechunking_3d[old1-new1-expected1]
distributed.shuffle.tests.test_rechunk ‑ test_calculate_prechunking_3d[old2-new2-expected2]
distributed.shuffle.tests.test_rechunk ‑ test_calculate_prechunking_3d[old3-new3-expected3]
distributed.shuffle.tests.test_rechunk ‑ test_calculate_prechunking_concatenation[1 B-expected0]
distributed.shuffle.tests.test_rechunk ‑ test_calculate_prechunking_concatenation[100 B-expected3]
distributed.shuffle.tests.test_rechunk ‑ test_calculate_prechunking_concatenation[20 B-expected1]
distributed.shuffle.tests.test_rechunk ‑ test_calculate_prechunking_concatenation[40 B-expected2]
distributed.shuffle.tests.test_rechunk ‑ test_calculate_prechunking_does_not_concatenate_object_type
distributed.shuffle.tests.test_rechunk ‑ test_calculate_prechunking_splitting[old0-new0-expected0]
distributed.shuffle.tests.test_rechunk ‑ test_calculate_prechunking_splitting[old1-new1-expected1]
distributed.shuffle.tests.test_rechunk ‑ test_calculate_prechunking_splitting[old2-new2-expected2]
distributed.shuffle.tests.test_rechunk ‑ test_cull_p2p_rechunk_independent_partitions
distributed.shuffle.tests.test_rechunk ‑ test_cull_p2p_rechunk_overlapping_partitions
distributed.shuffle.tests.test_rechunk ‑ test_cull_p2p_rechunking_single_chunk
distributed.shuffle.tests.test_rechunk ‑ test_dtype
distributed.shuffle.tests.test_rechunk ‑ test_homogeneously_schedule_unpack
distributed.shuffle.tests.test_rechunk ‑ test_lowlevel_rechunk[False-False-10]
distributed.shuffle.tests.test_rechunk ‑ test_lowlevel_rechunk[False-False-1]
distributed.shuffle.tests.test_rechunk ‑ test_lowlevel_rechunk[False-True-10]
distributed.shuffle.tests.test_rechunk ‑ test_lowlevel_rechunk[False-True-1]
distributed.shuffle.tests.test_rechunk ‑ test_lowlevel_rechunk[True-False-10]
distributed.shuffle.tests.test_rechunk ‑ test_lowlevel_rechunk[True-False-1]
distributed.shuffle.tests.test_rechunk ‑ test_lowlevel_rechunk[True-True-10]
distributed.shuffle.tests.test_rechunk ‑ test_lowlevel_rechunk[True-True-1]
distributed.shuffle.tests.test_rechunk ‑ test_partial_rechunk_homogeneous_distribution
distributed.shuffle.tests.test_rechunk ‑ test_partial_rechunk_taskgroups
distributed.shuffle.tests.test_rechunk ‑ test_pick_worker_homogeneous_distribution[1]
distributed.shuffle.tests.test_rechunk ‑ test_pick_worker_homogeneous_distribution[2]
distributed.shuffle.tests.test_rechunk ‑ test_pick_worker_homogeneous_distribution[41]
distributed.shuffle.tests.test_rechunk ‑ test_pick_worker_homogeneous_distribution[50]
distributed.shuffle.tests.test_rechunk ‑ test_preserve_writeable_flag
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_0d
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_2d[False]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_2d[True]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_4d[False]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_4d[True]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_auto_1d[100-1-10-expected0]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_auto_1d[100-100-10-expected2]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_auto_1d[100-50-10-expected1]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_auto_1d[20-7-10-expected3]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_auto_1d[20-chunks4-5-expected4]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_auto_2d
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_auto_3d
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_auto_image_stack[1000]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_auto_image_stack[100]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_avoid_needless_chunking
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_bad_keys
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_blockshape
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_configuration[None-None]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_configuration[None-p2p]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_configuration[None-tasks]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_configuration[p2p-None]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_configuration[p2p-p2p]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_configuration[p2p-tasks]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_configuration[tasks-None]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_configuration[tasks-p2p]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_configuration[tasks-tasks]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_datetime[p2p]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_datetime[tasks]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_down
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_empty
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_empty_array[arr0]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_empty_array[arr1]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_empty_array[arr2]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_empty_chunks
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_expand
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_expand2
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_heuristic[new0-p2p]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_heuristic[new1-tasks]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_heuristic[new2-tasks]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_heuristic[new3-p2p]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_in_memory_shards_dont_share_buffer
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_method
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_minus_one
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_same
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_same_fully_unknown
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_same_fully_unknown_floats
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_same_partially_unknown
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_unknown_from_array
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_unknown_from_pandas
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_unknown_raises
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_warning
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_dict
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_empty_input
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_fully_unknown_dimension[x0-chunks0]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_fully_unknown_dimension[x1-chunks1]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_fully_unknown_dimension[x10-chunks10]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_fully_unknown_dimension[x11-chunks11]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_fully_unknown_dimension[x2-chunks2]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_fully_unknown_dimension[x3-chunks3]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_fully_unknown_dimension[x4-chunks4]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_fully_unknown_dimension[x5-chunks5]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_fully_unknown_dimension[x6-chunks6]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_fully_unknown_dimension[x7-chunks7]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_fully_unknown_dimension[x8-chunks8]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_fully_unknown_dimension[x9-chunks9]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_fully_unknown_dimension_explicit[new_chunks0]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_fully_unknown_dimension_explicit[new_chunks1]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_fully_unknown_dimension_explicit[new_chunks2]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_integer
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_null_dimensions
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_partially_unknown_dimension[x0-chunks0]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_partially_unknown_dimension[x1-chunks1]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_partially_unknown_dimension[x10-chunks10]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_partially_unknown_dimension[x11-chunks11]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_partially_unknown_dimension[x2-chunks2]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_partially_unknown_dimension[x3-chunks3]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_partially_unknown_dimension[x4-chunks4]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_partially_unknown_dimension[x5-chunks5]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_partially_unknown_dimension[x6-chunks6]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_partially_unknown_dimension[x7-chunks7]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_partially_unknown_dimension[x8-chunks8]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_partially_unknown_dimension[x9-chunks9]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_zero
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_with_zero_placeholders
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_zero
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_zero_dim
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_zero_dim_array
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_zero_dim_array_II
distributed.shuffle.tests.test_rechunk ‑ test_split_axes_1
distributed.shuffle.tests.test_rechunk ‑ test_split_axes_2
distributed.shuffle.tests.test_rechunk ‑ test_split_axes_nan
distributed.shuffle.tests.test_rechunk ‑ test_split_axes_nan_long
distributed.shuffle.tests.test_rechunk ‑ test_split_axes_nan_single
distributed.shuffle.tests.test_rechunk ‑ test_split_axes_with_nonzero
distributed.shuffle.tests.test_rechunk ‑ test_split_axes_with_zero
distributed.shuffle.tests.test_shuffle
distributed.shuffle.tests.test_shuffle ‑ test_add_some_results
distributed.shuffle.tests.test_shuffle ‑ test_bad_disk
distributed.shuffle.tests.test_shuffle ‑ test_barrier_handles_stale_resumed_transfer
distributed.shuffle.tests.test_shuffle ‑ test_basic_cudf_support
distributed.shuffle.tests.test_shuffle ‑ test_basic_integration[False-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_integration[False-20]
distributed.shuffle.tests.test_shuffle ‑ test_basic_integration[False-None]
distributed.shuffle.tests.test_shuffle ‑ test_basic_integration[True-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_integration[True-20]
distributed.shuffle.tests.test_shuffle ‑ test_basic_integration[True-None]
distributed.shuffle.tests.test_shuffle ‑ test_basic_integration_local_cluster[False]
distributed.shuffle.tests.test_shuffle ‑ test_basic_integration_local_cluster[True]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-False-False-1-1-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-False-False-1-1-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-False-False-1-10-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-False-False-1-10-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-False-False-1-2-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-False-False-1-2-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-False-False-20-1-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-False-False-20-1-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-False-False-20-10-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-False-False-20-10-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-False-False-20-2-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-False-False-20-2-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-False-True-1-1-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-False-True-1-1-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-False-True-1-10-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-False-True-1-10-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-False-True-1-2-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-False-True-1-2-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-False-True-20-1-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-False-True-20-1-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-False-True-20-10-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-False-True-20-10-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-False-True-20-2-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-False-True-20-2-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-True-False-1-1-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-True-False-1-1-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-True-False-1-10-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-True-False-1-10-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-True-False-1-2-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-True-False-1-2-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-True-False-20-1-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-True-False-20-1-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-True-False-20-10-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-True-False-20-10-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-True-False-20-2-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-True-False-20-2-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-True-True-1-1-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-True-True-1-1-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-True-True-1-10-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-True-True-1-10-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-True-True-1-2-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-True-True-1-2-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-True-True-20-1-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-True-True-20-1-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-True-True-20-10-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-True-True-20-10-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-True-True-20-2-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-True-True-20-2-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-False-False-1-1-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-False-False-1-1-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-False-False-1-10-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-False-False-1-10-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-False-False-1-2-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-False-False-1-2-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-False-False-20-1-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-False-False-20-1-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-False-False-20-10-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-False-False-20-10-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-False-False-20-2-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-False-False-20-2-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-False-True-1-1-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-False-True-1-1-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-False-True-1-10-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-False-True-1-10-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-False-True-1-2-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-False-True-1-2-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-False-True-20-1-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-False-True-20-1-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-False-True-20-10-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-False-True-20-10-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-False-True-20-2-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-False-True-20-2-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-True-False-1-1-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-True-False-1-1-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-True-False-1-10-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-True-False-1-10-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-True-False-1-2-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-True-False-1-2-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-True-False-20-1-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-True-False-20-1-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-True-False-20-10-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-True-False-20-10-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-True-False-20-2-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-True-False-20-2-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-True-True-1-1-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-True-True-1-1-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-True-True-1-10-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-True-True-1-10-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-True-True-1-2-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-True-True-1-2-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-True-True-20-1-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-True-True-20-1-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-True-True-20-10-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-True-True-20-10-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-True-True-20-2-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-True-True-20-2-1]
distributed.shuffle.tests.test_shuffle ‑ test_clean_after_close
distributed.shuffle.tests.test_shuffle ‑ test_clean_after_forgotten_early
distributed.shuffle.tests.test_shuffle ‑ test_closed_bystanding_worker_during_shuffle
distributed.shuffle.tests.test_shuffle ‑ test_closed_input_only_worker_during_transfer
distributed.shuffle.tests.test_shuffle ‑ test_closed_other_worker_during_barrier
distributed.shuffle.tests.test_shuffle ‑ test_closed_worker_between_repeats
distributed.shuffle.tests.test_shuffle ‑ test_closed_worker_during_barrier
distributed.shuffle.tests.test_shuffle ‑ test_closed_worker_during_transfer
distributed.shuffle.tests.test_shuffle ‑ test_closed_worker_during_unpack
distributed.shuffle.tests.test_shuffle ‑ test_concurrent
distributed.shuffle.tests.test_shuffle ‑ test_crashed_input_only_worker_during_transfer
distributed.shuffle.tests.test_shuffle ‑ test_crashed_other_worker_during_barrier
distributed.shuffle.tests.test_shuffle ‑ test_crashed_worker_after_shuffle
distributed.shuffle.tests.test_shuffle ‑ test_crashed_worker_after_shuffle_persisted
distributed.shuffle.tests.test_shuffle ‑ test_crashed_worker_during_transfer
distributed.shuffle.tests.test_shuffle ‑ test_crashed_worker_during_unpack
distributed.shuffle.tests.test_shuffle ‑ test_deduplicate_stale_transfer[False]
distributed.shuffle.tests.test_shuffle ‑ test_deduplicate_stale_transfer[True]
distributed.shuffle.tests.test_shuffle ‑ test_delete_some_results
distributed.shuffle.tests.test_shuffle ‑ test_dont_downscale_participating_workers
distributed.shuffle.tests.test_shuffle ‑ test_drop_duplicates_stable_ordering[first-False]
distributed.shuffle.tests.test_shuffle ‑ test_drop_duplicates_stable_ordering[first-True]
distributed.shuffle.tests.test_shuffle ‑ test_drop_duplicates_stable_ordering[last-False]
distributed.shuffle.tests.test_shuffle ‑ test_drop_duplicates_stable_ordering[last-True]
distributed.shuffle.tests.test_shuffle ‑ test_erred_task_before_p2p_does_not_log_event
distributed.shuffle.tests.test_shuffle ‑ test_error_offload
distributed.shuffle.tests.test_shuffle ‑ test_error_receive[P2PConsistencyError]
distributed.shuffle.tests.test_shuffle ‑ test_error_receive[ValueError]
distributed.shuffle.tests.test_shuffle ‑ test_error_send
distributed.shuffle.tests.test_shuffle ‑ test_exception_on_close_cleans_up
distributed.shuffle.tests.test_shuffle ‑ test_fail_fetch_race
distributed.shuffle.tests.test_shuffle ‑ test_flaky_broadcast[failures0-None]
distributed.shuffle.tests.test_shuffle ‑ test_flaky_broadcast[failures1-None]
distributed.shuffle.tests.test_shuffle ‑ test_flaky_broadcast[failures2-RuntimeError]
distributed.shuffle.tests.test_shuffle ‑ test_flaky_broadcast[failures3-None]
distributed.shuffle.tests.test_shuffle ‑ test_flaky_broadcast[failures4-RuntimeError]
distributed.shuffle.tests.test_shuffle ‑ test_flaky_broadcast[failures5-RuntimeError]
distributed.shuffle.tests.test_shuffle ‑ test_flaky_broadcast[failures6-RuntimeError]
distributed.shuffle.tests.test_shuffle ‑ test_flaky_connect_fails_without_retry
distributed.shuffle.tests.test_shuffle ‑ test_flaky_connect_recover_with_retry
distributed.shuffle.tests.test_shuffle ‑ test_get_or_create_from_dangling_transfer
distributed.shuffle.tests.test_shuffle ‑ test_handle_categorical_data
distributed.shuffle.tests.test_shuffle ‑ test_handle_floats_in_int_meta
distributed.shuffle.tests.test_shuffle ‑ test_handle_null_partitions
distributed.shuffle.tests.test_shuffle ‑ test_handle_null_partitions_2
distributed.shuffle.tests.test_shuffle ‑ test_handle_object_columns
distributed.shuffle.tests.test_shuffle ‑ test_handle_stale_barrier[False]
distributed.shuffle.tests.test_shuffle ‑ test_handle_stale_barrier[True]
distributed.shuffle.tests.test_shuffle ‑ test_head
distributed.shuffle.tests.test_shuffle ‑ test_heartbeat
distributed.shuffle.tests.test_shuffle ‑ test_meaningful_out_of_disk_error
distributed.shuffle.tests.test_shuffle ‑ test_minimal_version
distributed.shuffle.tests.test_shuffle ‑ test_multi
distributed.shuffle.tests.test_shuffle ‑ test_new_worker
distributed.shuffle.tests.test_shuffle ‑ test_processing_chain[False]
distributed.shuffle.tests.test_shuffle ‑ test_processing_chain[True]
distributed.shuffle.tests.test_shuffle ‑ test_raise_on_incompatible_partitions
distributed.shuffle.tests.test_shuffle ‑ test_reconcile_partitions
distributed.shuffle.tests.test_shuffle ‑ test_repeat_shuffle_instance[False]
distributed.shuffle.tests.test_shuffle ‑ test_repeat_shuffle_instance[True]
distributed.shuffle.tests.test_shuffle ‑ test_repeat_shuffle_operation[False]
distributed.shuffle.tests.test_shuffle ‑ test_repeat_shuffle_operation[True]
distributed.shuffle.tests.test_shuffle ‑ test_replace_stale_shuffle
distributed.shuffle.tests.test_shuffle ‑ test_restarting_does_not_deadlock
distributed.shuffle.tests.test_shuffle ‑ test_restarting_does_not_log_p2p_failed
distributed.shuffle.tests.test_shuffle ‑ test_restarting_during_barrier_raises_killed_worker
distributed.shuffle.tests.test_shuffle ‑ test_restarting_during_transfer_raises_killed_worker
distributed.shuffle.tests.test_shuffle ‑ test_restarting_during_unpack_raises_killed_worker
distributed.shuffle.tests.test_shuffle ‑ test_restrictions
distributed.shuffle.tests.test_shuffle ‑ test_set_index
distributed.shuffle.tests.test_shuffle ‑ test_set_index_with_existing_index
distributed.shuffle.tests.test_shuffle ‑ test_shuffle_before_categorize
distributed.shuffle.tests.test_shuffle ‑ test_shuffle_run_consistency
distributed.shuffle.tests.test_shuffle ‑ test_shuffle_stable_ordering[first-False]
distributed.shuffle.tests.test_shuffle ‑ test_shuffle_stable_ordering[first-True]
distributed.shuffle.tests.test_shuffle ‑ test_shuffle_stable_ordering[last-False]
distributed.shuffle.tests.test_shuffle ‑ test_shuffle_stable_ordering[last-True]
distributed.shuffle.tests.test_shuffle ‑ test_shuffle_with_array_conversion[1]
distributed.shuffle.tests.test_shuffle ‑ test_shuffle_with_array_conversion[20]
distributed.shuffle.tests.test_shuffle ‑ test_shuffle_with_array_conversion[None]
distributed.shuffle.tests.test_shuffle ‑ test_shuffle_with_existing_index
distributed.shuffle.tests.test_shuffle ‑ test_sort_values_with_existing_divisions
distributed.shuffle.tests.test_shuffle ‑ test_split_by_partition[False]
distributed.shuffle.tests.test_shuffle ‑ test_split_by_partition[True]
distributed.shuffle.tests.test_shuffle ‑ test_split_by_worker
distributed.shuffle.tests.test_shuffle ‑ test_split_by_worker_empty
distributed.shuffle.tests.test_shuffle ‑ test_split_by_worker_many_workers
distributed.shuffle.tests.test_shuffle ‑ test_tail
distributed.shuffle.tests.test_shuffle ‑ test_unpack_gets_rescheduled_from_non_participating_worker
distributed.shuffle.tests.test_shuffle ‑ test_workers_do_not_spam_get_requests
distributed.shuffle.tests.test_shuffle ‑ test_wrong_meta_provided
distributed.shuffle.tests.test_shuffle_plugins
distributed.shuffle.tests.test_shuffle_plugins ‑ test_installation_on_scheduler
distributed.shuffle.tests.test_shuffle_plugins ‑ test_installation_on_worker
distributed.tests.test_active_memory_manager ‑ test_ReduceReplicas
distributed.tests.test_active_memory_manager ‑ test_ReduceReplicas_stress
distributed.tests.test_active_memory_manager ‑ test_ReduceReplicas_with_waiters[0-0-0-1]
distributed.tests.test_active_memory_manager ‑ test_ReduceReplicas_with_waiters[0-0-1-1]
distributed.tests.test_active_memory_manager ‑ test_ReduceReplicas_with_waiters[1-0-0-1]
distributed.tests.test_active_memory_manager ‑ test_ReduceReplicas_with_waiters[1-1-0-2]
distributed.tests.test_active_memory_manager ‑ test_ReduceReplicas_with_waiters[1-1-1-3]
distributed.tests.test_active_memory_manager ‑ test_ReduceReplicas_with_waiters[1-1-17-4]
distributed.tests.test_active_memory_manager ‑ test_ReduceReplicas_with_waiters[1-1-2-4]
distributed.tests.test_active_memory_manager ‑ test_ReduceReplicas_with_waiters[17-1-1-3]
distributed.tests.test_active_memory_manager ‑ test_ReduceReplicas_with_waiters[18-1-1-4]
distributed.tests.test_active_memory_manager ‑ test_ReduceReplicas_with_waiters[2-0-0-1]
distributed.tests.test_active_memory_manager ‑ test_ReduceReplicas_with_waiters[2-1-1-3]
distributed.tests.test_active_memory_manager ‑ test_RetireWorker_all_recipients_are_paused
distributed.tests.test_active_memory_manager ‑ test_RetireWorker_all_replicas_are_being_retired
distributed.tests.test_active_memory_manager ‑ test_RetireWorker_amm_on_off[False]
distributed.tests.test_active_memory_manager ‑ test_RetireWorker_amm_on_off[True]
distributed.tests.test_active_memory_manager ‑ test_RetireWorker_faulty_recipient
distributed.tests.test_active_memory_manager ‑ test_RetireWorker_incremental
distributed.tests.test_active_memory_manager ‑ test_RetireWorker_mass
distributed.tests.test_active_memory_manager ‑ test_RetireWorker_new_keys_arrive_after_all_keys_moved_away
distributed.tests.test_active_memory_manager ‑ test_RetireWorker_no_extension
distributed.tests.test_active_memory_manager ‑ test_RetireWorker_no_recipients
distributed.tests.test_active_memory_manager ‑ test_RetireWorker_no_remove
distributed.tests.test_active_memory_manager ‑ test_RetireWorker_stress[False]
distributed.tests.test_active_memory_manager ‑ test_RetireWorker_stress[True]
distributed.tests.test_active_memory_manager ‑ test_RetireWorker_with_ReduceReplicas[False]
distributed.tests.test_active_memory_manager ‑ test_RetireWorker_with_ReduceReplicas[True]
distributed.tests.test_active_memory_manager ‑ test_RetireWorker_with_actor[False]
distributed.tests.test_active_memory_manager ‑ test_RetireWorker_with_actor[True]
distributed.tests.test_active_memory_manager ‑ test_RetireWorker_with_actor_proxy
distributed.tests.test_active_memory_manager ‑ test_add_policy
distributed.tests.test_active_memory_manager ‑ test_auto_start
distributed.tests.test_active_memory_manager ‑ test_bad_measure
distributed.tests.test_active_memory_manager ‑ test_client_proxy_async
distributed.tests.test_active_memory_manager ‑ test_client_proxy_sync
distributed.tests.test_active_memory_manager ‑ test_dont_drop_actors
distributed.tests.test_active_memory_manager ‑ test_dont_replicate_actors
distributed.tests.test_active_memory_manager ‑ test_double_drop
distributed.tests.test_active_memory_manager ‑ test_double_drop_stress
distributed.tests.test_active_memory_manager ‑ test_double_replicate_stress
distributed.tests.test_active_memory_manager ‑ test_drop
distributed.tests.test_active_memory_manager ‑ test_drop_from_candidates_without_key
distributed.tests.test_active_memory_manager ‑ test_drop_from_worker_with_least_free_memory
distributed.tests.test_active_memory_manager ‑ test_drop_not_in_memory
distributed.tests.test_active_memory_manager ‑ test_drop_prefers_paused_workers
distributed.tests.test_active_memory_manager ‑ test_drop_stress
distributed.tests.test_active_memory_manager ‑ test_drop_with_bad_candidates
distributed.tests.test_active_memory_manager ‑ test_drop_with_candidates
distributed.tests.test_active_memory_manager ‑ test_drop_with_empty_candidates
distributed.tests.test_active_memory_manager ‑ test_drop_with_paused_workers_with_running_tasks_1
distributed.tests.test_active_memory_manager ‑ test_drop_with_paused_workers_with_running_tasks_2
distributed.tests.test_active_memory_manager ‑ test_drop_with_paused_workers_with_running_tasks_3_4[False]
distributed.tests.test_active_memory_manager ‑ test_drop_with_paused_workers_with_running_tasks_3_4[True]
distributed.tests.test_active_memory_manager ‑ test_drop_with_paused_workers_with_running_tasks_5
distributed.tests.test_active_memory_manager ‑ test_drop_with_waiter
distributed.tests.test_active_memory_manager ‑ test_multi_start
distributed.tests.test_active_memory_manager ‑ test_no_policies
distributed.tests.test_active_memory_manager ‑ test_noamm_stress
distributed.tests.test_active_memory_manager ‑ test_not_registered
distributed.tests.test_active_memory_manager ‑ test_replicate
distributed.tests.test_active_memory_manager ‑ test_replicate_avoids_paused_workers_1
distributed.tests.test_active_memory_manager ‑ test_replicate_avoids_paused_workers_2
distributed.tests.test_active_memory_manager ‑ test_replicate_not_in_memory
distributed.tests.test_active_memory_manager ‑ test_replicate_to_candidates_with_key
distributed.tests.test_active_memory_manager ‑ test_replicate_to_worker_with_most_free_memory
distributed.tests.test_active_memory_manager ‑ test_replicate_with_candidates
distributed.tests.test_active_memory_manager ‑ test_replicate_with_empty_candidates
distributed.tests.test_active_memory_manager ‑ test_start_stop
distributed.tests.test_actor ‑ test_Actor
distributed.tests.test_actor ‑ test_Actors_create_dependencies
distributed.tests.test_actor ‑ test_actor_future_awaitable
distributed.tests.test_actor ‑ test_actor_future_awaitable_deadlock
distributed.tests.test_actor ‑ test_actors_in_profile
distributed.tests.test_actor ‑ test_as_completed
distributed.tests.test_actor ‑ test_async_deadlock
distributed.tests.test_actor ‑ test_client_actions[False]
distributed.tests.test_actor ‑ test_client_actions[True]
distributed.tests.test_actor ‑ test_compute
distributed.tests.test_actor ‑ test_compute_sync
distributed.tests.test_actor ‑ test_dir
distributed.tests.test_actor ‑ test_exception
distributed.tests.test_actor ‑ test_exception_async
distributed.tests.test_actor ‑ test_exceptions_create
distributed.tests.test_actor ‑ test_exceptions_method
distributed.tests.test_actor ‑ test_failed_worker
distributed.tests.test_actor ‑ test_future
distributed.tests.test_actor ‑ test_future_dependencies
distributed.tests.test_actor ‑ test_gc
distributed.tests.test_actor ‑ test_get_worker
distributed.tests.test_actor ‑ test_linear_access
distributed.tests.test_actor ‑ test_load_balance
distributed.tests.test_actor ‑ test_load_balance_map
distributed.tests.test_actor ‑ test_many_computations
distributed.tests.test_actor ‑ test_numpy_roundtrip
distributed.tests.test_actor ‑ test_numpy_roundtrip_getattr
distributed.tests.test_actor ‑ test_one_thread_deadlock
distributed.tests.test_actor ‑ test_one_thread_deadlock_sync_client
distributed.tests.test_actor ‑ test_one_thread_deadlock_timeout
distributed.tests.test_actor ‑ test_repr
distributed.tests.test_actor ‑ test_serialize_with_pickle
distributed.tests.test_actor ‑ test_sync
distributed.tests.test_actor ‑ test_thread_safety
distributed.tests.test_actor ‑ test_timeout
distributed.tests.test_actor ‑ test_track_dependencies
distributed.tests.test_actor ‑ test_waiter
distributed.tests.test_actor ‑ test_worker_actions[False]
distributed.tests.test_actor ‑ test_worker_actions[True]
distributed.tests.test_actor ‑ test_worker_actor_handle_is_weakref
distributed.tests.test_actor ‑ test_worker_actor_handle_is_weakref_from_compute_sync
distributed.tests.test_actor ‑ test_worker_actor_handle_is_weakref_sync
distributed.tests.test_actor ‑ test_worker_client_async
distributed.tests.test_actor ‑ test_worker_client_separate_thread
distributed.tests.test_as_completed ‑ test_as_completed_add
distributed.tests.test_as_completed ‑ test_as_completed_async
distributed.tests.test_as_completed ‑ test_as_completed_cancel
distributed.tests.test_as_completed ‑ test_as_completed_cancel_last
distributed.tests.test_as_completed ‑ test_as_completed_error
distributed.tests.test_as_completed ‑ test_as_completed_error_async

Check notice on line 0 in .github

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

4130 tests found (test 1655 to 2617) 

There are 4130 tests, see "Raw output" for the list of tests 1655 to 2617.
Raw output 
distributed.tests.test_as_completed ‑ test_as_completed_is_empty
distributed.tests.test_as_completed ‑ test_as_completed_repeats
distributed.tests.test_as_completed ‑ test_as_completed_sync
distributed.tests.test_as_completed ‑ test_as_completed_timeout_async
distributed.tests.test_as_completed ‑ test_as_completed_timeout_sync
distributed.tests.test_as_completed ‑ test_as_completed_update
distributed.tests.test_as_completed ‑ test_as_completed_with_non_futures
distributed.tests.test_as_completed ‑ test_as_completed_with_results
distributed.tests.test_as_completed ‑ test_as_completed_with_results_async
distributed.tests.test_as_completed ‑ test_as_completed_with_results_no_raise
distributed.tests.test_as_completed ‑ test_as_completed_with_results_no_raise_async
distributed.tests.test_as_completed ‑ test_async_for_py2_equivalent
distributed.tests.test_as_completed ‑ test_clear
distributed.tests.test_as_completed ‑ test_str
distributed.tests.test_async_task_group ‑ test_async_task_group_call_later_executes_delayed_task_in_background
distributed.tests.test_async_task_group ‑ test_async_task_group_call_soon_executes_task_in_background
distributed.tests.test_async_task_group ‑ test_async_task_group_close_closes
distributed.tests.test_async_task_group ‑ test_async_task_group_close_does_not_cancel_existing_tasks
distributed.tests.test_async_task_group ‑ test_async_task_group_close_prohibits_new_tasks
distributed.tests.test_async_task_group ‑ test_async_task_group_initialization
distributed.tests.test_async_task_group ‑ test_async_task_group_stop_cancels_long_running
distributed.tests.test_async_task_group ‑ test_async_task_group_stop_disallows_shutdown
distributed.tests.test_asyncio ‑ test_rlock
distributed.tests.test_asyncio ‑ test_rlock_none
distributed.tests.test_asyncio ‑ test_rlock_nonreentrant
distributed.tests.test_asyncio ‑ test_rlock_release_on_raise
distributed.tests.test_asyncprocess ‑ test_asyncprocess_child_teardown_on_parent_exit
distributed.tests.test_asyncprocess ‑ test_child_main_thread
distributed.tests.test_asyncprocess ‑ test_close
distributed.tests.test_asyncprocess ‑ test_exit_callback
distributed.tests.test_asyncprocess ‑ test_exitcode
distributed.tests.test_asyncprocess ‑ test_kill
distributed.tests.test_asyncprocess ‑ test_num_fds
distributed.tests.test_asyncprocess ‑ test_sigint_from_same_process
distributed.tests.test_asyncprocess ‑ test_sigterm_from_parent_process
distributed.tests.test_asyncprocess ‑ test_simple
distributed.tests.test_asyncprocess ‑ test_terminate
distributed.tests.test_asyncprocess ‑ test_terminate_after_stop
distributed.tests.test_batched ‑ test_BatchedSend
distributed.tests.test_batched ‑ test_close_closed
distributed.tests.test_batched ‑ test_close_not_started
distributed.tests.test_batched ‑ test_close_twice
distributed.tests.test_batched ‑ test_large_traffic_jam
distributed.tests.test_batched ‑ test_send_after_stream_start
distributed.tests.test_batched ‑ test_send_before_close
distributed.tests.test_batched ‑ test_send_before_start
distributed.tests.test_batched ‑ test_sending_traffic_jam
distributed.tests.test_batched ‑ test_serializers
distributed.tests.test_batched ‑ test_stress
distributed.tests.test_cancelled_state ‑ test_abort_execution_add_as_dependency
distributed.tests.test_cancelled_state ‑ test_abort_execution_release
distributed.tests.test_cancelled_state ‑ test_abort_execution_reschedule
distributed.tests.test_cancelled_state ‑ test_abort_execution_to_fetch
distributed.tests.test_cancelled_state ‑ test_cancel_with_dependencies_in_memory[ExecuteFailureEvent-False]
distributed.tests.test_cancelled_state ‑ test_cancel_with_dependencies_in_memory[ExecuteFailureEvent-True]
distributed.tests.test_cancelled_state ‑ test_cancel_with_dependencies_in_memory[ExecuteSuccessEvent-False]
distributed.tests.test_cancelled_state ‑ test_cancel_with_dependencies_in_memory[ExecuteSuccessEvent-True]
distributed.tests.test_cancelled_state ‑ test_cancel_with_dependencies_in_memory[RescheduleEvent-False]
distributed.tests.test_cancelled_state ‑ test_cancel_with_dependencies_in_memory[RescheduleEvent-True]
distributed.tests.test_cancelled_state ‑ test_cancelled_error
distributed.tests.test_cancelled_state ‑ test_cancelled_error_with_resources
distributed.tests.test_cancelled_state ‑ test_cancelled_handle_compute[False]
distributed.tests.test_cancelled_state ‑ test_cancelled_handle_compute[True]
distributed.tests.test_cancelled_state ‑ test_cancelled_resumed_after_flight_with_dependencies
distributed.tests.test_cancelled_state ‑ test_cancelled_resumed_after_flight_with_dependencies_workerstate
distributed.tests.test_cancelled_state ‑ test_cancelled_task_error_rejected
distributed.tests.test_cancelled_state ‑ test_deadlock_cancelled_after_inflight_before_gather_from_worker[True-cancelled]
distributed.tests.test_cancelled_state ‑ test_deadlock_cancelled_after_inflight_before_gather_from_worker[True-resumed]
distributed.tests.test_cancelled_state ‑ test_execute_preamble_early_cancel[executing-False]
distributed.tests.test_cancelled_state ‑ test_execute_preamble_early_cancel[executing-True]
distributed.tests.test_cancelled_state ‑ test_execute_preamble_early_cancel[resumed-False]
distributed.tests.test_cancelled_state ‑ test_execute_preamble_early_cancel[resumed-True]
distributed.tests.test_cancelled_state ‑ test_executing_cancelled_error
distributed.tests.test_cancelled_state ‑ test_flight_cancelled_error
distributed.tests.test_cancelled_state ‑ test_flight_to_executing_via_cancelled_resumed
distributed.tests.test_cancelled_state ‑ test_in_flight_lost_after_resumed
distributed.tests.test_cancelled_state ‑ test_resumed_cancelled_handle_compute[False-False]
distributed.tests.test_cancelled_state ‑ test_resumed_cancelled_handle_compute[False-True]
distributed.tests.test_cancelled_state ‑ test_resumed_cancelled_handle_compute[True-False]
distributed.tests.test_cancelled_state ‑ test_resumed_cancelled_handle_compute[True-True]
distributed.tests.test_cancelled_state ‑ test_secede_cancelled_or_resumed_scheduler
distributed.tests.test_cancelled_state ‑ test_secede_cancelled_or_resumed_workerstate[ExecuteFailureEvent-False-False]
distributed.tests.test_cancelled_state ‑ test_secede_cancelled_or_resumed_workerstate[ExecuteFailureEvent-False-True]
distributed.tests.test_cancelled_state ‑ test_secede_cancelled_or_resumed_workerstate[ExecuteFailureEvent-True-False]
distributed.tests.test_cancelled_state ‑ test_secede_cancelled_or_resumed_workerstate[ExecuteFailureEvent-True-True]
distributed.tests.test_cancelled_state ‑ test_secede_cancelled_or_resumed_workerstate[ExecuteSuccessEvent-False-False]
distributed.tests.test_cancelled_state ‑ test_secede_cancelled_or_resumed_workerstate[ExecuteSuccessEvent-False-True]
distributed.tests.test_cancelled_state ‑ test_secede_cancelled_or_resumed_workerstate[ExecuteSuccessEvent-True-False]
distributed.tests.test_cancelled_state ‑ test_secede_cancelled_or_resumed_workerstate[ExecuteSuccessEvent-True-True]
distributed.tests.test_cancelled_state ‑ test_secede_cancelled_or_resumed_workerstate[RescheduleEvent-False-False]
distributed.tests.test_cancelled_state ‑ test_secede_cancelled_or_resumed_workerstate[RescheduleEvent-False-True]
distributed.tests.test_cancelled_state ‑ test_secede_cancelled_or_resumed_workerstate[RescheduleEvent-True-False]
distributed.tests.test_cancelled_state ‑ test_secede_cancelled_or_resumed_workerstate[RescheduleEvent-True-True]
distributed.tests.test_cancelled_state ‑ test_worker_stream_died_during_comm
distributed.tests.test_cancelled_state ‑ test_workerstate_executing_failure_to_fetch[executing]
distributed.tests.test_cancelled_state ‑ test_workerstate_executing_failure_to_fetch[long-running]
distributed.tests.test_cancelled_state ‑ test_workerstate_executing_skips_fetch_on_success[executing]
distributed.tests.test_cancelled_state ‑ test_workerstate_executing_skips_fetch_on_success[long-running]
distributed.tests.test_cancelled_state ‑ test_workerstate_executing_to_executing[executing]
distributed.tests.test_cancelled_state ‑ test_workerstate_executing_to_executing[long-running]
distributed.tests.test_cancelled_state ‑ test_workerstate_flight_failure_to_executing[False]
distributed.tests.test_cancelled_state ‑ test_workerstate_flight_failure_to_executing[True]
distributed.tests.test_cancelled_state ‑ test_workerstate_flight_skips_executing_on_success
distributed.tests.test_cancelled_state ‑ test_workerstate_flight_to_flight
distributed.tests.test_cancelled_state ‑ test_workerstate_remove_replica_of_cancelled_task_dependency
distributed.tests.test_cancelled_state ‑ test_workerstate_resumed_fetch_to_cancelled_to_executing[executing]
distributed.tests.test_cancelled_state ‑ test_workerstate_resumed_fetch_to_cancelled_to_executing[long-running]
distributed.tests.test_cancelled_state ‑ test_workerstate_resumed_fetch_to_executing[executing]
distributed.tests.test_cancelled_state ‑ test_workerstate_resumed_fetch_to_executing[long-running]
distributed.tests.test_cancelled_state ‑ test_workerstate_resumed_waiting_to_flight
distributed.tests.test_chaos ‑ test_KillWorker[graceful]
distributed.tests.test_chaos ‑ test_KillWorker[segfault]
distributed.tests.test_chaos ‑ test_KillWorker[sys.exit]
distributed.tests.test_client ‑ test_Client_clears_references_after_restart
distributed.tests.test_client ‑ test_Future_exception
distributed.tests.test_client ‑ test_Future_exception_sync
distributed.tests.test_client ‑ test_Future_exception_sync_2
distributed.tests.test_client ‑ test_Future_release
distributed.tests.test_client ‑ test_Future_release_sync
distributed.tests.test_client ‑ test__broadcast
distributed.tests.test_client ‑ test__broadcast_dict
distributed.tests.test_client ‑ test__broadcast_integer
distributed.tests.test_client ‑ test_add_done_callback
distributed.tests.test_client ‑ test_add_worker_after_tasks
distributed.tests.test_client ‑ test_aliases
distributed.tests.test_client ‑ test_aliases_2
distributed.tests.test_client ‑ test_allow_restrictions
distributed.tests.test_client ‑ test_annotations_blockwise_unpack
distributed.tests.test_client ‑ test_annotations_compute_time[compute]
distributed.tests.test_client ‑ test_annotations_compute_time[persist]
distributed.tests.test_client ‑ test_annotations_global_vs_local
distributed.tests.test_client ‑ test_annotations_loose_restrictions
distributed.tests.test_client ‑ test_annotations_priorities
distributed.tests.test_client ‑ test_annotations_resources
distributed.tests.test_client ‑ test_annotations_resources_culled
distributed.tests.test_client ‑ test_annotations_retries
distributed.tests.test_client ‑ test_annotations_submit_map
distributed.tests.test_client ‑ test_annotations_survive_optimization
distributed.tests.test_client ‑ test_annotations_task_state
distributed.tests.test_client ‑ test_annotations_workers
distributed.tests.test_client ‑ test_as_completed_async_for
distributed.tests.test_client ‑ test_as_completed_async_for_cancel
distributed.tests.test_client ‑ test_as_completed_async_for_results
distributed.tests.test_client ‑ test_as_completed_batches[False]
distributed.tests.test_client ‑ test_as_completed_batches[True]
distributed.tests.test_client ‑ test_as_completed_condition_loop
distributed.tests.test_client ‑ test_as_completed_list
distributed.tests.test_client ‑ test_as_completed_next_batch
distributed.tests.test_client ‑ test_as_completed_results
distributed.tests.test_client ‑ test_as_current
distributed.tests.test_client ‑ test_as_current_is_task_local
distributed.tests.test_client ‑ test_as_current_is_thread_local
distributed.tests.test_client ‑ test_async_compute
distributed.tests.test_client ‑ test_async_compute_with_scatter
distributed.tests.test_client ‑ test_async_persist
distributed.tests.test_client ‑ test_async_task
distributed.tests.test_client ‑ test_async_task_with_partial
distributed.tests.test_client ‑ test_async_with
distributed.tests.test_client ‑ test_auto_normalize_collection
distributed.tests.test_client ‑ test_auto_normalize_collection_sync
distributed.tests.test_client ‑ test_avoid_delayed_finalize
distributed.tests.test_client ‑ test_await_future
distributed.tests.test_client ‑ test_bad_address
distributed.tests.test_client ‑ test_bad_tasks_fail
distributed.tests.test_client ‑ test_badly_serialized_exceptions
distributed.tests.test_client ‑ test_badly_serialized_input_stderr
distributed.tests.test_client ‑ test_balance_tasks_by_stacks
distributed.tests.test_client ‑ test_balanced_with_submit
distributed.tests.test_client ‑ test_balanced_with_submit_and_resident_data
distributed.tests.test_client ‑ test_benchmark_hardware_no_workers
distributed.tests.test_client ‑ test_bytes_keys
distributed.tests.test_client ‑ test_call_stack_all
distributed.tests.test_client ‑ test_call_stack_collections
distributed.tests.test_client ‑ test_call_stack_collections_all
distributed.tests.test_client ‑ test_call_stack_future
distributed.tests.test_client ‑ test_cancel
distributed.tests.test_client ‑ test_cancel_before_known_to_scheduler
distributed.tests.test_client ‑ test_cancel_clears_processing
distributed.tests.test_client ‑ test_cancel_collection
distributed.tests.test_client ‑ test_cancel_multi_client
distributed.tests.test_client ‑ test_cancel_sync
distributed.tests.test_client ‑ test_cancel_tuple_key
distributed.tests.test_client ‑ test_cleanup_after_broken_client_connection
distributed.tests.test_client ‑ test_client_async_before_loop_starts
distributed.tests.test_client ‑ test_client_disconnect_exception_on_cancelled_futures
distributed.tests.test_client ‑ test_client_doesnt_close_given_loop
distributed.tests.test_client ‑ test_client_is_quiet_cluster_close
distributed.tests.test_client ‑ test_client_name
distributed.tests.test_client ‑ test_client_num_fds
distributed.tests.test_client ‑ test_client_replicate
distributed.tests.test_client ‑ test_client_replicate_host
distributed.tests.test_client ‑ test_client_replicate_sync
distributed.tests.test_client ‑ test_client_repr_closed
distributed.tests.test_client ‑ test_client_repr_closed_sync
distributed.tests.test_client ‑ test_client_sync_with_async_def
distributed.tests.test_client ‑ test_client_timeout
distributed.tests.test_client ‑ test_client_timeout_2
distributed.tests.test_client ‑ test_client_with_name
distributed.tests.test_client ‑ test_client_with_scheduler
distributed.tests.test_client ‑ test_close
distributed.tests.test_client ‑ test_close_idempotent
distributed.tests.test_client ‑ test_computation_code_walk_frames
distributed.tests.test_client ‑ test_computation_ignore_ipython_frames[2]
distributed.tests.test_client ‑ test_computation_ignore_ipython_frames[3]
distributed.tests.test_client ‑ test_computation_object_code_client_compute
distributed.tests.test_client ‑ test_computation_object_code_client_map
distributed.tests.test_client ‑ test_computation_object_code_client_submit_dict_comp
distributed.tests.test_client ‑ test_computation_object_code_client_submit_list_comp
distributed.tests.test_client ‑ test_computation_object_code_client_submit_simple
distributed.tests.test_client ‑ test_computation_object_code_dask_compute
distributed.tests.test_client ‑ test_computation_object_code_dask_compute_no_frames_default
distributed.tests.test_client ‑ test_computation_object_code_dask_persist
distributed.tests.test_client ‑ test_computation_object_code_not_available
distributed.tests.test_client ‑ test_computation_store_annotations
distributed.tests.test_client ‑ test_compute_nested_containers
distributed.tests.test_client ‑ test_compute_retries
distributed.tests.test_client ‑ test_compute_retries_annotations
distributed.tests.test_client ‑ test_compute_workers
distributed.tests.test_client ‑ test_compute_workers_annotate
distributed.tests.test_client ‑ test_config_inherited_by_subprocess
distributed.tests.test_client ‑ test_config_scheduler_address
distributed.tests.test_client ‑ test_context_manager_used_from_different_tasks
distributed.tests.test_client ‑ test_context_manager_used_from_different_threads
distributed.tests.test_client ‑ test_contiguous_load
distributed.tests.test_client ‑ test_current
distributed.tests.test_client ‑ test_current_concurrent
distributed.tests.test_client ‑ test_current_nested
distributed.tests.test_client ‑ test_current_nested_async
distributed.tests.test_client ‑ test_custom_key_with_batches
distributed.tests.test_client ‑ test_dashboard_link
distributed.tests.test_client ‑ test_dashboard_link_cluster
distributed.tests.test_client ‑ test_dashboard_link_inproc
distributed.tests.test_client ‑ test_de_serialization
distributed.tests.test_client ‑ test_de_serialization_none
distributed.tests.test_client ‑ test_default_get
distributed.tests.test_client ‑ test_deprecated_loop_properties
distributed.tests.test_client ‑ test_diagnostic_nbytes
distributed.tests.test_client ‑ test_diagnostic_nbytes_sync
distributed.tests.test_client ‑ test_diagnostic_ui
distributed.tests.test_client ‑ test_direct_async
distributed.tests.test_client ‑ test_direct_sync
distributed.tests.test_client ‑ test_direct_to_workers
distributed.tests.test_client ‑ test_directed_scatter
distributed.tests.test_client ‑ test_distribute_tasks_by_nthreads
distributed.tests.test_client ‑ test_dont_hold_on_to_large_messages
distributed.tests.test_client ‑ test_duck_typed_register_plugin_raises
distributed.tests.test_client ‑ test_dump_cluster_state_async[msgpack-False]
distributed.tests.test_client ‑ test_dump_cluster_state_async[msgpack-True]
distributed.tests.test_client ‑ test_dump_cluster_state_async[yaml-False]
distributed.tests.test_client ‑ test_dump_cluster_state_async[yaml-True]
distributed.tests.test_client ‑ test_dump_cluster_state_exclude_default
distributed.tests.test_client ‑ test_dump_cluster_state_json[False]
distributed.tests.test_client ‑ test_dump_cluster_state_json[True]
distributed.tests.test_client ‑ test_dump_cluster_state_sync[msgpack-False]
distributed.tests.test_client ‑ test_dump_cluster_state_sync[msgpack-True]
distributed.tests.test_client ‑ test_dump_cluster_state_sync[yaml-False]
distributed.tests.test_client ‑ test_dump_cluster_state_sync[yaml-True]
distributed.tests.test_client ‑ test_dump_cluster_state_write_from_scheduler
distributed.tests.test_client ‑ test_dynamic_workloads_sync
distributed.tests.test_client ‑ test_dynamic_workloads_sync_random
distributed.tests.test_client ‑ test_ensure_default_client
distributed.tests.test_client ‑ test_errors_dont_block
distributed.tests.test_client ‑ test_even_load_after_fast_functions
distributed.tests.test_client ‑ test_even_load_on_startup
distributed.tests.test_client ‑ test_exception_on_exception
distributed.tests.test_client ‑ test_exception_text
distributed.tests.test_client ‑ test_exceptions
distributed.tests.test_client ‑ test_fast_close_on_aexit_failure
distributed.tests.test_client ‑ test_file_descriptors_dont_leak[Nanny]
distributed.tests.test_client ‑ test_file_descriptors_dont_leak[Worker]
distributed.tests.test_client ‑ test_fire_and_forget
distributed.tests.test_client ‑ test_fire_and_forget_err
distributed.tests.test_client ‑ test_forget_complex
distributed.tests.test_client ‑ test_forget_errors
distributed.tests.test_client ‑ test_forget_in_flight
distributed.tests.test_client ‑ test_forget_simple
distributed.tests.test_client ‑ test_forward_logging
distributed.tests.test_client ‑ test_future_repr
distributed.tests.test_client ‑ test_future_tuple_repr
distributed.tests.test_client ‑ test_future_type
distributed.tests.test_client ‑ test_futures_in_subgraphs
distributed.tests.test_client ‑ test_futures_of_cancelled_raises
distributed.tests.test_client ‑ test_futures_of_class
distributed.tests.test_client ‑ test_futures_of_get
distributed.tests.test_client ‑ test_futures_of_sorted
distributed.tests.test_client ‑ test_garbage_collection
distributed.tests.test_client ‑ test_garbage_collection_with_scatter
distributed.tests.test_client ‑ test_gather
distributed.tests.test_client ‑ test_gather_direct
distributed.tests.test_client ‑ test_gather_errors
distributed.tests.test_client ‑ test_gather_lost
distributed.tests.test_client ‑ test_gather_mismatched_client
distributed.tests.test_client ‑ test_gather_race_vs_AMM[False]
distributed.tests.test_client ‑ test_gather_race_vs_AMM[True]
distributed.tests.test_client ‑ test_gather_skip
distributed.tests.test_client ‑ test_gather_strict
distributed.tests.test_client ‑ test_gather_sync
distributed.tests.test_client ‑ test_gather_traceback
distributed.tests.test_client ‑ test_gc
distributed.tests.test_client ‑ test_get
distributed.tests.test_client ‑ test_get_client
distributed.tests.test_client ‑ test_get_client_functions_spawn_clusters
distributed.tests.test_client ‑ test_get_client_no_cluster
distributed.tests.test_client ‑ test_get_client_sync
distributed.tests.test_client ‑ test_get_foo
distributed.tests.test_client ‑ test_get_foo_lost_keys
distributed.tests.test_client ‑ test_get_mix_futures_and_SubgraphCallable
distributed.tests.test_client ‑ test_get_mix_futures_and_SubgraphCallable_dask_dataframe
distributed.tests.test_client ‑ test_get_nbytes
distributed.tests.test_client ‑ test_get_processing_sync
distributed.tests.test_client ‑ test_get_releases_data
distributed.tests.test_client ‑ test_get_returns_early
distributed.tests.test_client ‑ test_get_scheduler_default_client_config_interleaving
distributed.tests.test_client ‑ test_get_stops_work_after_error
distributed.tests.test_client ‑ test_get_sync
distributed.tests.test_client ‑ test_get_sync_optimize_graph_passes_through
distributed.tests.test_client ‑ test_get_task_metadata
distributed.tests.test_client ‑ test_get_task_metadata_multiple
distributed.tests.test_client ‑ test_get_task_prefix_states
distributed.tests.test_client ‑ test_get_traceback
distributed.tests.test_client ‑ test_get_versions_async
distributed.tests.test_client ‑ test_get_versions_rpc_error
distributed.tests.test_client ‑ test_get_versions_sync
distributed.tests.test_client ‑ test_get_with_error
distributed.tests.test_client ‑ test_get_with_error_sync
distributed.tests.test_client ‑ test_get_with_non_list_key
distributed.tests.test_client ‑ test_global_clients
distributed.tests.test_client ‑ test_idempotence
distributed.tests.test_client ‑ test_identity
distributed.tests.test_client ‑ test_if_intermediates_clear_on_error
distributed.tests.test_client ‑ test_informative_error_on_cluster_type
distributed.tests.test_client ‑ test_instances
distributed.tests.test_client ‑ test_interleave_computations
distributed.tests.test_client ‑ test_interleave_computations_map
distributed.tests.test_client ‑ test_limit_concurrent_gathering
distributed.tests.test_client ‑ test_logs
distributed.tests.test_client ‑ test_logs_from_worker_submodules
distributed.tests.test_client ‑ test_long_error
distributed.tests.test_client ‑ test_long_running_not_in_occupancy[False]
distributed.tests.test_client ‑ test_long_running_not_in_occupancy[True]
distributed.tests.test_client ‑ test_long_running_removal_clean[False]
distributed.tests.test_client ‑ test_long_running_removal_clean[True]
distributed.tests.test_client ‑ test_long_tasks_dont_trigger_timeout
distributed.tests.test_client ‑ test_long_traceback
distributed.tests.test_client ‑ test_lose_scattered_data
distributed.tests.test_client ‑ test_many_submits_spread_evenly
distributed.tests.test_client ‑ test_map
distributed.tests.test_client ‑ test_map_batch_size
distributed.tests.test_client ‑ test_map_differnet_lengths
distributed.tests.test_client ‑ test_map_empty
distributed.tests.test_client ‑ test_map_keynames
distributed.tests.test_client ‑ test_map_large_kwargs_in_graph
distributed.tests.test_client ‑ test_map_list_kwargs
distributed.tests.test_client ‑ test_map_naming
distributed.tests.test_client ‑ test_map_on_futures_with_kwargs
distributed.tests.test_client ‑ test_map_quotes
distributed.tests.test_client ‑ test_map_retries
distributed.tests.test_client ‑ test_mixed_compression
distributed.tests.test_client ‑ test_mixing_clients_different_scheduler
distributed.tests.test_client ‑ test_mixing_clients_same_scheduler
distributed.tests.test_client ‑ test_multi_client
distributed.tests.test_client ‑ test_multi_garbage_collection
distributed.tests.test_client ‑ test_multiple_clients
distributed.tests.test_client ‑ test_multiple_scatter
distributed.tests.test_client ‑ test_nbytes_determines_worker
distributed.tests.test_client ‑ test_nested_compute
distributed.tests.test_client ‑ test_nested_prioritization
distributed.tests.test_client ‑ test_no_future_references
distributed.tests.test_client ‑ test_no_threads_lingering
distributed.tests.test_client ‑ test_normalize_collection
distributed.tests.test_client ‑ test_normalize_collection_dask_array
distributed.tests.test_client ‑ test_normalize_collection_with_released_futures
distributed.tests.test_client ‑ test_partially_lose_scattered_data
distributed.tests.test_client ‑ test_performance_report[False]
distributed.tests.test_client ‑ test_performance_report[True]
distributed.tests.test_client ‑ test_persist
distributed.tests.test_client ‑ test_persist_async
distributed.tests.test_client ‑ test_persist_get[False]
distributed.tests.test_client ‑ test_persist_get[True]
distributed.tests.test_client ‑ test_persist_get_sync
distributed.tests.test_client ‑ test_persist_optimize_graph
distributed.tests.test_client ‑ test_persist_retries
distributed.tests.test_client ‑ test_persist_retries_annotations
distributed.tests.test_client ‑ test_persist_workers
distributed.tests.test_client ‑ test_persist_workers_annotate
distributed.tests.test_client ‑ test_persist_workers_annotate2
distributed.tests.test_client ‑ test_pragmatic_move_small_data_to_large_data
distributed.tests.test_client ‑ test_print_local
distributed.tests.test_client ‑ test_print_manual
distributed.tests.test_client ‑ test_print_manual_bad_args
distributed.tests.test_client ‑ test_print_non_msgpack_serializable
distributed.tests.test_client ‑ test_print_remote
distributed.tests.test_client ‑ test_profile
distributed.tests.test_client ‑ test_profile_bokeh
distributed.tests.test_client ‑ test_profile_disabled
distributed.tests.test_client ‑ test_profile_keys
distributed.tests.test_client ‑ test_profile_server
distributed.tests.test_client ‑ test_profile_server_disabled
distributed.tests.test_client ‑ test_proxy
distributed.tests.test_client ‑ test_quiet_client_close
distributed.tests.test_client ‑ test_quiet_client_close_when_cluster_is_closed_before_client
distributed.tests.test_client ‑ test_quiet_close_process[False]
distributed.tests.test_client ‑ test_quiet_close_process[True]
distributed.tests.test_client ‑ test_quiet_quit_when_cluster_leaves
distributed.tests.test_client ‑ test_quiet_scheduler_loss
distributed.tests.test_client ‑ test_rebalance
distributed.tests.test_client ‑ test_rebalance_sync
distributed.tests.test_client ‑ test_rebalance_unprepared
distributed.tests.test_client ‑ test_rebalance_workers_and_keys
distributed.tests.test_client ‑ test_receive_lost_key
distributed.tests.test_client ‑ test_recompute_released_key
distributed.tests.test_client ‑ test_reconnect
distributed.tests.test_client ‑ test_reconnect_timeout
distributed.tests.test_client ‑ test_recreate_error_not_error
distributed.tests.test_client ‑ test_recreate_error_sync
distributed.tests.test_client ‑ test_recreate_task_sync
distributed.tests.test_client ‑ test_register_worker_plugin_exception
distributed.tests.test_client ‑ test_register_worker_plugin_instance_required
distributed.tests.test_client ‑ test_release_persisted_collection
distributed.tests.test_client ‑ test_release_persisted_collection_sync
distributed.tests.test_client ‑ test_released_dependencies
distributed.tests.test_client ‑ test_remote_scatter_gather
distributed.tests.test_client ‑ test_remote_submit_on_Future
distributed.tests.test_client ‑ test_remove_worker
distributed.tests.test_client ‑ test_replicate
distributed.tests.test_client ‑ test_replicate_tree_branching
distributed.tests.test_client ‑ test_replicate_tuple_keys
distributed.tests.test_client ‑ test_replicate_workers
distributed.tests.test_client ‑ test_repr[func2]
distributed.tests.test_client ‑ test_repr[repr]
distributed.tests.test_client ‑ test_repr[str]
distributed.tests.test_client ‑ test_repr_async
distributed.tests.test_client ‑ test_repr_localcluster
distributed.tests.test_client ‑ test_repr_no_memory_limit
distributed.tests.test_client ‑ test_repr_sync
distributed.tests.test_client ‑ test_resolves_future_in_dict
distributed.tests.test_client ‑ test_resolves_future_in_namedtuple[NewArgsExNamedTuple-args2-kwargs2]
distributed.tests.test_client ‑ test_resolves_future_in_namedtuple[NewArgsNamedTuple-args1-kwargs1]
distributed.tests.test_client ‑ test_resolves_future_in_namedtuple[PlainNamedTuple-args0-kwargs0]
distributed.tests.test_client ‑ test_restart_workers
distributed.tests.test_client ‑ test_restart_workers_by_name[False]
distributed.tests.test_client ‑ test_restart_workers_by_name[True]
distributed.tests.test_client ‑ test_restart_workers_exception
distributed.tests.test_client ‑ test_restart_workers_kill_timeout[False]
distributed.tests.test_client ‑ test_restart_workers_kill_timeout[True]
distributed.tests.test_client ‑ test_restart_workers_no_nanny_raises
distributed.tests.test_client ‑ test_restart_workers_restart_timeout[False]
distributed.tests.test_client ‑ test_restart_workers_restart_timeout[True]
distributed.tests.test_client ‑ test_restrictions_get
distributed.tests.test_client ‑ test_restrictions_get_annotate
distributed.tests.test_client ‑ test_restrictions_ip_port
distributed.tests.test_client ‑ test_restrictions_map
distributed.tests.test_client ‑ test_restrictions_submit
distributed.tests.test_client ‑ test_retire_many_workers
distributed.tests.test_client ‑ test_retire_workers
distributed.tests.test_client ‑ test_retire_workers_2
distributed.tests.test_client ‑ test_retries_dask_array
distributed.tests.test_client ‑ test_retries_get
distributed.tests.test_client ‑ test_retry
distributed.tests.test_client ‑ test_retry_dependencies
distributed.tests.test_client ‑ test_robust_undeserializable
distributed.tests.test_client ‑ test_robust_undeserializable_function
distributed.tests.test_client ‑ test_robust_unserializable
distributed.tests.test_client ‑ test_run
distributed.tests.test_client ‑ test_run_coroutine
distributed.tests.test_client ‑ test_run_coroutine_sync
distributed.tests.test_client ‑ test_run_exception
distributed.tests.test_client ‑ test_run_handles_picklable_data
distributed.tests.test_client ‑ test_run_on_scheduler_async_def
distributed.tests.test_client ‑ test_run_on_scheduler_async_def_wait
distributed.tests.test_client ‑ test_run_rpc_error
distributed.tests.test_client ‑ test_run_sync
distributed.tests.test_client ‑ test_scatter
distributed.tests.test_client ‑ test_scatter_and_replicate_avoid_paused_workers[10-False-False]
distributed.tests.test_client ‑ test_scatter_and_replicate_avoid_paused_workers[10-False-True]
distributed.tests.test_client ‑ test_scatter_and_replicate_avoid_paused_workers[10-True-False]
distributed.tests.test_client ‑ test_scatter_and_replicate_avoid_paused_workers[10-True-True]
distributed.tests.test_client ‑ test_scatter_and_replicate_avoid_paused_workers[False-False-False]
distributed.tests.test_client ‑ test_scatter_and_replicate_avoid_paused_workers[False-False-True]
distributed.tests.test_client ‑ test_scatter_and_replicate_avoid_paused_workers[False-True-False]
distributed.tests.test_client ‑ test_scatter_and_replicate_avoid_paused_workers[False-True-True]
distributed.tests.test_client ‑ test_scatter_and_replicate_avoid_paused_workers[True-False-False]
distributed.tests.test_client ‑ test_scatter_and_replicate_avoid_paused_workers[True-False-True]
distributed.tests.test_client ‑ test_scatter_and_replicate_avoid_paused_workers[True-True-False]
distributed.tests.test_client ‑ test_scatter_and_replicate_avoid_paused_workers[True-True-True]
distributed.tests.test_client ‑ test_scatter_compute_lose
distributed.tests.test_client ‑ test_scatter_compute_store_lose
distributed.tests.test_client ‑ test_scatter_compute_store_lose_processing
distributed.tests.test_client ‑ test_scatter_dict_workers
distributed.tests.test_client ‑ test_scatter_direct
distributed.tests.test_client ‑ test_scatter_direct_2
distributed.tests.test_client ‑ test_scatter_direct_balanced
distributed.tests.test_client ‑ test_scatter_direct_broadcast
distributed.tests.test_client ‑ test_scatter_direct_broadcast_target
distributed.tests.test_client ‑ test_scatter_direct_empty
distributed.tests.test_client ‑ test_scatter_direct_numpy
distributed.tests.test_client ‑ test_scatter_direct_spread_evenly
distributed.tests.test_client ‑ test_scatter_error_cancel
distributed.tests.test_client ‑ test_scatter_gather_sync[False-False]
distributed.tests.test_client ‑ test_scatter_gather_sync[False-True]
distributed.tests.test_client ‑ test_scatter_gather_sync[True-False]
distributed.tests.test_client ‑ test_scatter_gather_sync[True-True]
distributed.tests.test_client ‑ test_scatter_hash
distributed.tests.test_client ‑ test_scatter_hash_2
distributed.tests.test_client ‑ test_scatter_non_list
distributed.tests.test_client ‑ test_scatter_raises_if_no_workers
distributed.tests.test_client ‑ test_scatter_singletons
distributed.tests.test_client ‑ test_scatter_tokenize_local
distributed.tests.test_client ‑ test_scatter_type
distributed.tests.test_client ‑ test_scatter_typename
distributed.tests.test_client ‑ test_scatter_types
distributed.tests.test_client ‑ test_scheduler_info
distributed.tests.test_client ‑ test_scheduler_restart_exception_on_cancelled_futures
distributed.tests.test_client ‑ test_scheduler_saturates_cores
distributed.tests.test_client ‑ test_scheduler_saturates_cores_random
distributed.tests.test_client ‑ test_secede_balances
distributed.tests.test_client ‑ test_secede_simple
distributed.tests.test_client ‑ test_serialize_collections
distributed.tests.test_client ‑ test_serialize_collections_of_futures
distributed.tests.test_client ‑ test_serialize_collections_of_futures_sync
distributed.tests.test_client ‑ test_set_as_default
distributed.tests.test_client ‑ test_short_tracebacks[gather]
distributed.tests.test_client ‑ test_short_tracebacks[result]
distributed.tests.test_client ‑ test_short_tracebacks_async[await]
distributed.tests.test_client ‑ test_short_tracebacks_async[gather]
distributed.tests.test_client ‑ test_short_tracebacks_async[result]
distributed.tests.test_client ‑ test_shutdown
distributed.tests.test_client ‑ test_shutdown_is_quiet_with_cluster
distributed.tests.test_client ‑ test_shutdown_localcluster
distributed.tests.test_client ‑ test_shutdown_stops_callbacks
distributed.tests.test_client ‑ test_start_is_idempotent
distributed.tests.test_client ‑ test_startup_close_startup
distributed.tests.test_client ‑ test_startup_close_startup_sync
distributed.tests.test_client ‑ test_status
distributed.tests.test_client ‑ test_sub_submit_priority
distributed.tests.test_client ‑ test_submit
distributed.tests.test_client ‑ test_submit_list_kwargs
distributed.tests.test_client ‑ test_submit_naming
distributed.tests.test_client ‑ test_submit_on_cancelled_future
distributed.tests.test_client ‑ test_submit_quotes
distributed.tests.test_client ‑ test_submit_then_get_with_Future
distributed.tests.test_client ‑ test_sync_compute
distributed.tests.test_client ‑ test_sync_exceptions
distributed.tests.test_client ‑ test_task_load_adapts_quickly
distributed.tests.test_client ‑ test_task_metadata
distributed.tests.test_client ‑ test_temp_default_client
distributed.tests.test_client ‑ test_thread
distributed.tests.test_client ‑ test_threaded_get_within_distributed
distributed.tests.test_client ‑ test_threadsafe
distributed.tests.test_client ‑ test_threadsafe_compute
distributed.tests.test_client ‑ test_threadsafe_get
distributed.tests.test_client ‑ test_tokenize_on_futures
distributed.tests.test_client ‑ test_traceback
distributed.tests.test_client ‑ test_traceback_clean
distributed.tests.test_client ‑ test_traceback_sync
distributed.tests.test_client ‑ test_tuple_keys
distributed.tests.test_client ‑ test_turn_off_pickle[False]
distributed.tests.test_client ‑ test_turn_off_pickle[True]
distributed.tests.test_client ‑ test_two_consecutive_clients_share_results
distributed.tests.test_client ‑ test_unhashable_function
distributed.tests.test_client ‑ test_unicode_ascii_keys
distributed.tests.test_client ‑ test_unicode_keys
distributed.tests.test_client ‑ test_unpacks_remotedata_namedtuple[NewArgsExNamedTuple-args2-kwargs2]
distributed.tests.test_client ‑ test_unpacks_remotedata_namedtuple[NewArgsNamedTuple-args1-kwargs1]
distributed.tests.test_client ‑ test_unpacks_remotedata_namedtuple[PlainNamedTuple-args0-kwargs0]
distributed.tests.test_client ‑ test_unrunnable_task_runs
distributed.tests.test_client ‑ test_upload_directory
distributed.tests.test_client ‑ test_upload_file
distributed.tests.test_client ‑ test_upload_file_egg
distributed.tests.test_client ‑ test_upload_file_exception
distributed.tests.test_client ‑ test_upload_file_exception_sync
distributed.tests.test_client ‑ test_upload_file_load
distributed.tests.test_client ‑ test_upload_file_new_worker
distributed.tests.test_client ‑ test_upload_file_no_extension
distributed.tests.test_client ‑ test_upload_file_refresh_delayed
distributed.tests.test_client ‑ test_upload_file_sync
distributed.tests.test_client ‑ test_upload_file_zip
distributed.tests.test_client ‑ test_upload_large_file
distributed.tests.test_client ‑ test_use_synchronous_client_in_async_context
distributed.tests.test_client ‑ test_wait
distributed.tests.test_client ‑ test_wait_first_completed
distributed.tests.test_client ‑ test_wait_for_workers
distributed.tests.test_client ‑ test_wait_for_workers_n_workers_value_check[0-ValueError]
distributed.tests.test_client ‑ test_wait_for_workers_n_workers_value_check[1-None]
distributed.tests.test_client ‑ test_wait_for_workers_n_workers_value_check[1.0-ValueError]
distributed.tests.test_client ‑ test_wait_for_workers_n_workers_value_check[2-None]
distributed.tests.test_client ‑ test_wait_for_workers_n_workers_value_check[None-ValueError]
distributed.tests.test_client ‑ test_wait_for_workers_updates_info
distributed.tests.test_client ‑ test_wait_informative_error_for_timeouts
distributed.tests.test_client ‑ test_wait_on_collections
distributed.tests.test_client ‑ test_wait_sync
distributed.tests.test_client ‑ test_wait_timeout
distributed.tests.test_client ‑ test_warn_manual
distributed.tests.test_client ‑ test_warn_remote
distributed.tests.test_client ‑ test_warn_when_submitting_large_values
distributed.tests.test_client ‑ test_warn_when_submitting_large_values_memoryview
distributed.tests.test_client ‑ test_weight_occupancy_against_data_movement
distributed.tests.test_client ‑ test_worker_aliases
distributed.tests.test_client ‑ test_worker_clients_do_not_claim_ownership_of_serialize_futures[False]
distributed.tests.test_client ‑ test_worker_clients_do_not_claim_ownership_of_serialize_futures[True]
distributed.tests.test_client ‑ test_workers_collection_restriction
distributed.tests.test_client ‑ test_workers_register_indirect_data
distributed.tests.test_client ‑ test_write_scheduler_file
distributed.tests.test_client.TestClientSecurityLoader ‑ test_security_loader
distributed.tests.test_client.TestClientSecurityLoader ‑ test_security_loader_ignored_if_explicit_security_provided
distributed.tests.test_client.TestClientSecurityLoader ‑ test_security_loader_ignored_if_returns_none
distributed.tests.test_client.TestClientSecurityLoader ‑ test_security_loader_import_failed
distributed.tests.test_client_executor ‑ test_as_completed
distributed.tests.test_client_executor ‑ test_cancellation
distributed.tests.test_client_executor ‑ test_cancellation_as_completed
distributed.tests.test_client_executor ‑ test_cancellation_wait
distributed.tests.test_client_executor ‑ test_map
distributed.tests.test_client_executor ‑ test_pure
distributed.tests.test_client_executor ‑ test_retries
distributed.tests.test_client_executor ‑ test_shutdown_nowait
distributed.tests.test_client_executor ‑ test_shutdown_wait
distributed.tests.test_client_executor ‑ test_submit
distributed.tests.test_client_executor ‑ test_unsupported_arguments
distributed.tests.test_client_executor ‑ test_wait
distributed.tests.test_client_executor ‑ test_workers
distributed.tests.test_client_loop ‑ test_close_loop_sync_start_new_loop
distributed.tests.test_client_loop ‑ test_close_loop_sync_use_running_loop
distributed.tests.test_cluster_dump ‑ test_cluster_dump_state
distributed.tests.test_cluster_dump ‑ test_cluster_dump_story
distributed.tests.test_cluster_dump ‑ test_cluster_dump_to_yamls
distributed.tests.test_cluster_dump ‑ test_tuple_to_list[foo-foo]
distributed.tests.test_cluster_dump ‑ test_tuple_to_list[input0-expected0]
distributed.tests.test_cluster_dump ‑ test_tuple_to_list[input1-expected1]
distributed.tests.test_cluster_dump ‑ test_tuple_to_list[input2-expected2]
distributed.tests.test_cluster_dump ‑ test_write_state_msgpack
distributed.tests.test_cluster_dump ‑ test_write_state_yaml
distributed.tests.test_collections ‑ test_heapset
distributed.tests.test_collections ‑ test_heapset_pickle
distributed.tests.test_collections ‑ test_heapset_popright[False]
distributed.tests.test_collections ‑ test_heapset_popright[True]
distributed.tests.test_collections ‑ test_heapset_sort_duplicate
distributed.tests.test_collections ‑ test_heapset_sorted_flag_left
distributed.tests.test_collections ‑ test_heapset_sorted_flag_right
distributed.tests.test_collections ‑ test_lru
distributed.tests.test_collections ‑ test_sum_mappings
distributed.tests.test_compatibility ‑ test_randbytes
distributed.tests.test_compatibility ‑ test_randbytes_seed
distributed.tests.test_computations ‑ test_computations
distributed.tests.test_computations ‑ test_computations_futures
distributed.tests.test_computations ‑ test_computations_long_running
distributed.tests.test_computations ‑ test_computations_no_resources
distributed.tests.test_computations ‑ test_computations_no_workers
distributed.tests.test_config ‑ test_basic_config_does_not_override_default_logging
distributed.tests.test_config ‑ test_default_logging_does_not_override_basic_config
distributed.tests.test_config ‑ test_deprecations_on_env_variables
distributed.tests.test_config ‑ test_deprecations_on_set[args0-kwargs0]
distributed.tests.test_config ‑ test_deprecations_on_set[args1-kwargs1]
distributed.tests.test_config ‑ test_deprecations_on_set[args2-kwargs2]
distributed.tests.test_config ‑ test_deprecations_on_yaml[allowed-failures]
distributed.tests.test_config ‑ test_deprecations_on_yaml[allowed_failures]
distributed.tests.test_config ‑ test_logging_default[None]
distributed.tests.test_config ‑ test_logging_default[config0]
distributed.tests.test_config ‑ test_logging_extended
distributed.tests.test_config ‑ test_logging_file_config
distributed.tests.test_config ‑ test_logging_mutual_exclusive
distributed.tests.test_config ‑ test_logging_simple
distributed.tests.test_config ‑ test_logging_simple_under_distributed
distributed.tests.test_config ‑ test_schema
distributed.tests.test_config ‑ test_schema_is_complete
distributed.tests.test_config ‑ test_uvloop_event_loop
distributed.tests.test_core ‑ test_async_listener_stop
distributed.tests.test_core ‑ test_close_fast_without_active_handlers[False]
distributed.tests.test_core ‑ test_close_fast_without_active_handlers[True]
distributed.tests.test_core ‑ test_close_grace_period_for_handlers
distributed.tests.test_core ‑ test_close_properly
distributed.tests.test_core ‑ test_coerce_to_address
distributed.tests.test_core ‑ test_compression[echo_no_serialize-False]
distributed.tests.test_core ‑ test_compression[echo_no_serialize-None]
distributed.tests.test_core ‑ test_compression[echo_no_serialize-auto]
distributed.tests.test_core ‑ test_compression[echo_no_serialize-lz4]
distributed.tests.test_core ‑ test_compression[echo_no_serialize-snappy]
distributed.tests.test_core ‑ test_compression[echo_no_serialize-zlib]
distributed.tests.test_core ‑ test_compression[echo_no_serialize-zstd]
distributed.tests.test_core ‑ test_compression[echo_serialize-False]
distributed.tests.test_core ‑ test_compression[echo_serialize-None]
distributed.tests.test_core ‑ test_compression[echo_serialize-auto]
distributed.tests.test_core ‑ test_compression[echo_serialize-lz4]
distributed.tests.test_core ‑ test_compression[echo_serialize-snappy]
distributed.tests.test_core ‑ test_compression[echo_serialize-zlib]
distributed.tests.test_core ‑ test_compression[echo_serialize-zstd]
distributed.tests.test_core ‑ test_connect_raises
distributed.tests.test_core ‑ test_connection_pool
distributed.tests.test_core ‑ test_connection_pool_catch_all_cancellederrors
distributed.tests.test_core ‑ test_connection_pool_close_while_connecting
distributed.tests.test_core ‑ test_connection_pool_detects_remote_close
distributed.tests.test_core ‑ test_connection_pool_outside_cancellation
distributed.tests.test_core ‑ test_connection_pool_remove
distributed.tests.test_core ‑ test_connection_pool_respects_limit
distributed.tests.test_core ‑ test_connection_pool_tls
distributed.tests.test_core ‑ test_counters
distributed.tests.test_core ‑ test_deserialize_error
distributed.tests.test_core ‑ test_errors
distributed.tests.test_core ‑ test_expects_comm
distributed.tests.test_core ‑ test_identity_inproc
distributed.tests.test_core ‑ test_identity_tcp
distributed.tests.test_core ‑ test_large_packets_inproc
distributed.tests.test_core ‑ test_large_packets_tcp
distributed.tests.test_core ‑ test_large_payload
distributed.tests.test_core ‑ test_messages_are_ordered_bsend
distributed.tests.test_core ‑ test_messages_are_ordered_raw
distributed.tests.test_core ‑ test_ports
distributed.tests.test_core ‑ test_remove_cancels_connect_attempts
distributed.tests.test_core ‑ test_remove_cancels_connect_before_task_running
distributed.tests.test_core ‑ test_rpc_closed_exception
distributed.tests.test_core ‑ test_rpc_default
distributed.tests.test_core ‑ test_rpc_inproc
distributed.tests.test_core ‑ test_rpc_inputs
distributed.tests.test_core ‑ test_rpc_message_lifetime_default
distributed.tests.test_core ‑ test_rpc_message_lifetime_inproc
distributed.tests.test_core ‑ test_rpc_message_lifetime_tcp
distributed.tests.test_core ‑ test_rpc_serialization
distributed.tests.test_core ‑ test_rpc_tcp
distributed.tests.test_core ‑ test_rpc_tls
distributed.tests.test_core ‑ test_rpc_with_many_connections_inproc
distributed.tests.test_core ‑ test_rpc_with_many_connections_tcp
distributed.tests.test_core ‑ test_send_recv_args
distributed.tests.test_core ‑ test_send_recv_cancelled
distributed.tests.test_core ‑ test_server
distributed.tests.test_core ‑ test_server_assign_assign_enum_is_quiet
distributed.tests.test_core ‑ test_server_close_stops_gil_monitoring
distributed.tests.test_core ‑ test_server_comms_mark_active_handlers
distributed.tests.test_core ‑ test_server_listen
distributed.tests.test_core ‑ test_server_raises_on_blocked_handlers
distributed.tests.test_core ‑ test_server_redundant_kwarg
distributed.tests.test_core ‑ test_server_status_compare_enum_is_quiet
distributed.tests.test_core ‑ test_server_status_is_always_enum
distributed.tests.test_core ‑ test_server_sys_path_local_directory_cleanup
distributed.tests.test_core ‑ test_thread_id
distributed.tests.test_core ‑ test_tick_logging
distributed.tests.test_core ‑ test_ticks
distributed.tests.test_counter ‑ test_counter
distributed.tests.test_counter ‑ test_digest[Counter-<lambda>]
distributed.tests.test_counter ‑ test_digest[Digest-<lambda>]
distributed.tests.test_counter ‑ test_digest[None-<lambda>]
distributed.tests.test_dask_collections
distributed.tests.test_dask_collections ‑ test_bag_groupby_key_hashing
distributed.tests.test_dask_collections ‑ test_bag_groupby_tasks_default
distributed.tests.test_dask_collections ‑ test_dask_array_collections
distributed.tests.test_dask_collections ‑ test_dataframe_groupby_tasks
distributed.tests.test_dask_collections ‑ test_dataframe_set_index_sync[<lambda>]
distributed.tests.test_dask_collections ‑ test_dataframe_set_index_sync[wait]
distributed.tests.test_dask_collections ‑ test_dataframes
distributed.tests.test_dask_collections ‑ test_delayed_none
distributed.tests.test_dask_collections ‑ test_loc
distributed.tests.test_dask_collections ‑ test_loc_sync
distributed.tests.test_dask_collections ‑ test_rolling_sync
distributed.tests.test_dask_collections ‑ test_sparse_arrays
distributed.tests.test_dask_collections ‑ test_tuple_futures_arg[list]
distributed.tests.test_dask_collections ‑ test_tuple_futures_arg[tuple]
distributed.tests.test_deadline ‑ test_deadline
distributed.tests.test_deadline ‑ test_deadline_expiration
distributed.tests.test_deadline ‑ test_deadline_expiration_async
distributed.tests.test_deadline ‑ test_deadline_progress
distributed.tests.test_deadline ‑ test_infinite_deadline
distributed.tests.test_diskutils ‑ test_locking_disabled
distributed.tests.test_diskutils ‑ test_two_workspaces_in_same_directory
distributed.tests.test_diskutils ‑ test_unwritable_base_dir
distributed.tests.test_diskutils ‑ test_workdir_simple
distributed.tests.test_diskutils ‑ test_workspace_concurrency
distributed.tests.test_diskutils ‑ test_workspace_process_crash
distributed.tests.test_diskutils ‑ test_workspace_rmtree_failure
distributed.tests.test_event_logging ‑ test_configurable_events_log_length
distributed.tests.test_event_logging ‑ test_events_all_servers_use_same_channel
distributed.tests.test_event_logging ‑ test_events_subscribe_topic
distributed.tests.test_event_logging ‑ test_events_subscribe_topic_cancelled
distributed.tests.test_event_logging ‑ test_events_unsubscribe_raises_if_unknown
distributed.tests.test_event_logging ‑ test_log_event
distributed.tests.test_event_logging ‑ test_log_event_e2e
distributed.tests.test_event_logging ‑ test_log_event_msgpack
distributed.tests.test_event_logging ‑ test_log_event_multiple_clients
distributed.tests.test_event_logging ‑ test_log_event_on_nanny
distributed.tests.test_event_logging ‑ test_log_event_on_worker
distributed.tests.test_event_logging ‑ test_log_event_plugin
distributed.tests.test_event_logging ‑ test_log_event_plugin_multiple_topics
distributed.tests.test_event_logging ‑ test_log_events
distributed.tests.test_event_logging ‑ test_topic_subscribe_unsubscribe
distributed.tests.test_events ‑ test_default_event
distributed.tests.test_events ‑ test_event_on_workers
distributed.tests.test_events ‑ test_event_sync
distributed.tests.test_events ‑ test_event_types
distributed.tests.test_events ‑ test_serializable
distributed.tests.test_events ‑ test_set_not_set
distributed.tests.test_events ‑ test_set_not_set_many_events
distributed.tests.test_events ‑ test_timeout
distributed.tests.test_events ‑ test_two_events_on_workers
distributed.tests.test_events ‑ test_unpickle_without_client
distributed.tests.test_failed_workers ‑ test_broken_worker_during_computation
distributed.tests.test_failed_workers ‑ test_failing_worker_with_additional_replicas_on_cluster
distributed.tests.test_failed_workers ‑ test_forget_data_not_supposed_to_have
distributed.tests.test_failed_workers ‑ test_forgotten_futures_dont_clean_up_new_futures
distributed.tests.test_failed_workers ‑ test_gather_after_failed_worker
distributed.tests.test_failed_workers ‑ test_gather_then_submit_after_failed_workers
distributed.tests.test_failed_workers ‑ test_multiple_clients_restart
distributed.tests.test_failed_workers ‑ test_restart
distributed.tests.test_failed_workers ‑ test_restart_cleared
distributed.tests.test_failed_workers ‑ test_restart_during_computation
distributed.tests.test_failed_workers ‑ test_restart_hung_worker
distributed.tests.test_failed_workers ‑ test_restart_scheduler
distributed.tests.test_failed_workers ‑ test_restart_sync
distributed.tests.test_failed_workers ‑ test_restart_timeout_on_long_running_task
distributed.tests.test_failed_workers ‑ test_submit_after_failed_worker
distributed.tests.test_failed_workers ‑ test_submit_after_failed_worker_async[False-False-closed]
distributed.tests.test_failed_workers ‑ test_submit_after_failed_worker_async[False-False-closing]
distributed.tests.test_failed_workers ‑ test_submit_after_failed_worker_async[False-True-closed]
distributed.tests.test_failed_workers ‑ test_submit_after_failed_worker_async[False-True-closing]
distributed.tests.test_failed_workers ‑ test_submit_after_failed_worker_async[True-False-closed]
distributed.tests.test_failed_workers ‑ test_submit_after_failed_worker_async[True-False-closing]
distributed.tests.test_failed_workers ‑ test_submit_after_failed_worker_async[True-True-closed]
distributed.tests.test_failed_workers ‑ test_submit_after_failed_worker_async[True-True-closing]
distributed.tests.test_failed_workers ‑ test_submit_after_failed_worker_sync
distributed.tests.test_failed_workers ‑ test_worker_doesnt_await_task_completion
distributed.tests.test_failed_workers ‑ test_worker_same_host_replicas_missing
distributed.tests.test_failed_workers ‑ test_worker_time_to_live
distributed.tests.test_failed_workers ‑ test_worker_ttl_restarts_worker[False]
distributed.tests.test_failed_workers ‑ test_worker_ttl_restarts_worker[True]
distributed.tests.test_failed_workers ‑ test_worker_who_has_clears_after_failed_connection
distributed.tests.test_gc ‑ test_fractional_timer
distributed.tests.test_gc ‑ test_gc_diagnosis_cpu_time
distributed.tests.test_gc ‑ test_gc_diagnosis_rss_win
distributed.tests.test_imports ‑ test_can_import_distributed_in_background_thread
distributed.tests.test_init ‑ test_git_revision
distributed.tests.test_init ‑ test_version
distributed.tests.test_itertools ‑ test_ffill
distributed.tests.test_jupyter
distributed.tests.test_jupyter ‑ test_jupyter_cli
distributed.tests.test_jupyter ‑ test_jupyter_idle_timeout
distributed.tests.test_jupyter ‑ test_jupyter_idle_timeout_returned
distributed.tests.test_jupyter ‑ test_jupyter_server
distributed.tests.test_jupyter ‑ test_shutsdown_cleanly
distributed.tests.test_locks ‑ test_acquires_blocking
distributed.tests.test_locks ‑ test_acquires_with_zero_timeout
distributed.tests.test_locks ‑ test_errors
distributed.tests.test_locks ‑ test_lock
distributed.tests.test_locks ‑ test_lock_sync
distributed.tests.test_locks ‑ test_lock_types
distributed.tests.test_locks ‑ test_locks
distributed.tests.test_locks ‑ test_locks_inf_lease_timeout
distributed.tests.test_locks ‑ test_serializable
distributed.tests.test_locks ‑ test_serializable_no_ctx
distributed.tests.test_locks ‑ test_timeout
distributed.tests.test_locks ‑ test_timeout_sync
distributed.tests.test_metrics ‑ test_context_meter
distributed.tests.test_metrics ‑ test_context_meter_allow_offload
distributed.tests.test_metrics ‑ test_context_meter_clear_callbacks
distributed.tests.test_metrics ‑ test_context_meter_clear_callbacks_raises
distributed.tests.test_metrics ‑ test_context_meter_decorator
distributed.tests.test_metrics ‑ test_context_meter_keyed
distributed.tests.test_metrics ‑ test_context_meter_nested
distributed.tests.test_metrics ‑ test_context_meter_nested_floor
distributed.tests.test_metrics ‑ test_context_meter_pickle
distributed.tests.test_metrics ‑ test_context_meter_raise
distributed.tests.test_metrics ‑ test_delayed_metrics_ledger
distributed.tests.test_metrics ‑ test_delayed_metrics_ledger_keyed
distributed.tests.test_metrics ‑ test_meter
distributed.tests.test_metrics ‑ test_meter_floor[kwargs0-0]
distributed.tests.test_metrics ‑ test_meter_floor[kwargs1-0.1]
distributed.tests.test_metrics ‑ test_meter_floor[kwargs2--1]
distributed.tests.test_metrics ‑ test_meter_raise
distributed.tests.test_metrics ‑ test_monotonic
distributed.tests.test_metrics ‑ test_wall_clock[monotonic]
distributed.tests.test_metrics ‑ test_wall_clock[time]
distributed.tests.test_multi_locks ‑ test_multiple_locks
distributed.tests.test_multi_locks ‑ test_num_locks
distributed.tests.test_multi_locks ‑ test_single_lock
distributed.tests.test_multi_locks ‑ test_timeout
distributed.tests.test_multi_locks ‑ test_timeout_wake_waiter
distributed.tests.test_nanny ‑ test_close_joins
distributed.tests.test_nanny ‑ test_close_on_disconnect
distributed.tests.test_nanny ‑ test_config
distributed.tests.test_nanny ‑ test_config_param_overlays
distributed.tests.test_nanny ‑ test_default_client_does_not_propagate_to_subprocess
distributed.tests.test_nanny ‑ test_environ_plugin
distributed.tests.test_nanny ‑ test_environment_variable
distributed.tests.test_nanny ‑ test_environment_variable_by_config
distributed.tests.test_nanny ‑ test_environment_variable_config
distributed.tests.test_nanny ‑ test_environment_variable_overlay
distributed.tests.test_nanny ‑ test_environment_variable_pre_post_spawn
distributed.tests.test_nanny ‑ test_failure_during_worker_initialization
distributed.tests.test_nanny ‑ test_lifetime
distributed.tests.test_nanny ‑ test_local_directory
distributed.tests.test_nanny ‑ test_malloc_trim_threshold
distributed.tests.test_nanny ‑ test_mp_pool_worker_no_daemon
distributed.tests.test_nanny ‑ test_mp_process_worker_no_daemon
distributed.tests.test_nanny ‑ test_nanny_alt_worker_class
distributed.tests.test_nanny ‑ test_nanny_closed_by_keyboard_interrupt[tcp]
distributed.tests.test_nanny ‑ test_nanny_closed_by_keyboard_interrupt[ucx]
distributed.tests.test_nanny ‑ test_nanny_closes_cleanly
distributed.tests.test_nanny ‑ test_nanny_closes_cleanly_if_worker_is_terminated
distributed.tests.test_nanny ‑ test_nanny_death_timeout
distributed.tests.test_nanny ‑ test_nanny_plugin_register_during_start_failure[False]
distributed.tests.test_nanny ‑ test_nanny_plugin_register_during_start_failure[True]
distributed.tests.test_nanny ‑ test_nanny_plugin_register_during_start_success[False]
distributed.tests.test_nanny ‑ test_nanny_plugin_register_during_start_success[True]
distributed.tests.test_nanny ‑ test_nanny_plugin_register_nanny_killed[False]
distributed.tests.test_nanny ‑ test_nanny_plugin_register_nanny_killed[True]
distributed.tests.test_nanny ‑ test_nanny_plugin_simple
distributed.tests.test_nanny ‑ test_nanny_port_range
distributed.tests.test_nanny ‑ test_nanny_process_failure
distributed.tests.test_nanny ‑ test_nanny_restart
distributed.tests.test_nanny ‑ test_nanny_restart_timeout
distributed.tests.test_nanny ‑ test_nanny_restart_timeout_stress
distributed.tests.test_nanny ‑ test_nanny_worker_class
distributed.tests.test_nanny ‑ test_no_hang_when_scheduler_closes
distributed.tests.test_nanny ‑ test_no_unnecessary_imports_on_worker[pandas]
distributed.tests.test_nanny ‑ test_no_unnecessary_imports_on_worker[scipy]
distributed.tests.test_nanny ‑ test_num_fds
distributed.tests.test_nanny ‑ test_random_seed
distributed.tests.test_nanny ‑ test_repeated_restarts
distributed.tests.test_nanny ‑ test_restart_memory
distributed.tests.test_nanny ‑ test_run
distributed.tests.test_nanny ‑ test_scheduler_address_config
distributed.tests.test_nanny ‑ test_scheduler_crash_doesnt_restart
distributed.tests.test_nanny ‑ test_scheduler_file
distributed.tests.test_nanny ‑ test_str
distributed.tests.test_nanny ‑ test_throttle_outgoing_transfers
distributed.tests.test_nanny ‑ test_unwriteable_dask_worker_space
distributed.tests.test_nanny ‑ test_wait_for_scheduler
distributed.tests.test_nanny ‑ test_worker_inherits_temp_config
distributed.tests.test_nanny ‑ test_worker_start_exception
distributed.tests.test_nanny ‑ test_worker_start_exception_while_killing
distributed.tests.test_nanny ‑ test_worker_uses_same_host_as_nanny
distributed.tests.test_parse_stdout ‑ test_build_xml
distributed.tests.test_parse_stdout ‑ test_parse_rows
distributed.tests.test_preload ‑ test_client_preload_click
distributed.tests.test_preload ‑ test_client_preload_config
distributed.tests.test_preload ‑ test_client_preload_config_click
distributed.tests.test_preload ‑ test_client_preload_text
distributed.tests.test_preload ‑ test_failure_doesnt_crash_client
distributed.tests.test_preload ‑ test_failure_doesnt_crash_nanny
distributed.tests.test_preload ‑ test_failure_doesnt_crash_scheduler
distributed.tests.test_preload ‑ test_failure_doesnt_crash_worker
distributed.tests.test_preload ‑ test_preload_import_time
distributed.tests.test_preload ‑ test_preload_manager_sequence
distributed.tests.test_preload ‑ test_scheduler_startup
distributed.tests.test_preload ‑ test_scheduler_startup_nanny
distributed.tests.test_preload ‑ test_web_preload
distributed.tests.test_preload ‑ test_web_preload_worker
distributed.tests.test_preload ‑ test_worker_preload_click
distributed.tests.test_preload ‑ test_worker_preload_click_async
distributed.tests.test_preload ‑ test_worker_preload_config
distributed.tests.test_preload ‑ test_worker_preload_file
distributed.tests.test_preload ‑ test_worker_preload_module
distributed.tests.test_preload ‑ test_worker_preload_text
distributed.tests.test_priorities ‑ test_annotate_compute[queue on scheduler]
distributed.tests.test_priorities ‑ test_annotate_compute[queue on worker]
distributed.tests.test_priorities ‑ test_annotate_persist[queue on scheduler]
distributed.tests.test_priorities ‑ test_annotate_persist[queue on worker]
distributed.tests.test_priorities ‑ test_compute[queue on scheduler]
distributed.tests.test_priorities ‑ test_compute[queue on worker]
distributed.tests.test_priorities ‑ test_last_in_first_out[queue on scheduler]
distributed.tests.test_priorities ‑ test_last_in_first_out[queue on worker]
distributed.tests.test_priorities ‑ test_map[queue on scheduler]
distributed.tests.test_priorities ‑ test_map[queue on worker]
distributed.tests.test_priorities ‑ test_persist[queue on scheduler]
distributed.tests.test_priorities ‑ test_persist[queue on worker]
distributed.tests.test_priorities ‑ test_repeated_persists_same_priority[queue on scheduler]
distributed.tests.test_priorities ‑ test_repeated_persists_same_priority[queue on worker]
distributed.tests.test_priorities ‑ test_submit[queue on scheduler]

Check notice on line 0 in .github

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

4130 tests found (test 2618 to 3547) 

There are 4130 tests, see "Raw output" for the list of tests 2618 to 3547.
Raw output 
distributed.tests.test_priorities ‑ test_submit[queue on worker]
distributed.tests.test_profile ‑ test_basic
distributed.tests.test_profile ‑ test_basic_low_level
distributed.tests.test_profile ‑ test_builtin
distributed.tests.test_profile ‑ test_call_stack
distributed.tests.test_profile ‑ test_call_stack_f_lineno[-1-1]
distributed.tests.test_profile ‑ test_call_stack_f_lineno[0-2]
distributed.tests.test_profile ‑ test_call_stack_f_lineno[1-2]
distributed.tests.test_profile ‑ test_call_stack_f_lineno[100-2]
distributed.tests.test_profile ‑ test_call_stack_f_lineno[11-2]
distributed.tests.test_profile ‑ test_call_stack_f_lineno[12-3]
distributed.tests.test_profile ‑ test_call_stack_f_lineno[21-4]
distributed.tests.test_profile ‑ test_call_stack_f_lineno[22-4]
distributed.tests.test_profile ‑ test_call_stack_f_lineno[23-4]
distributed.tests.test_profile ‑ test_call_stack_f_lineno[24-2]
distributed.tests.test_profile ‑ test_call_stack_f_lineno[25-2]
distributed.tests.test_profile ‑ test_call_stack_f_lineno[26-2]
distributed.tests.test_profile ‑ test_call_stack_f_lineno[27-2]
distributed.tests.test_profile ‑ test_identifier
distributed.tests.test_profile ‑ test_info_frame_f_lineno[-1-1]
distributed.tests.test_profile ‑ test_info_frame_f_lineno[0-2]
distributed.tests.test_profile ‑ test_info_frame_f_lineno[1-2]
distributed.tests.test_profile ‑ test_info_frame_f_lineno[100-2]
distributed.tests.test_profile ‑ test_info_frame_f_lineno[11-2]
distributed.tests.test_profile ‑ test_info_frame_f_lineno[12-3]
distributed.tests.test_profile ‑ test_info_frame_f_lineno[21-4]
distributed.tests.test_profile ‑ test_info_frame_f_lineno[22-4]
distributed.tests.test_profile ‑ test_info_frame_f_lineno[23-4]
distributed.tests.test_profile ‑ test_info_frame_f_lineno[24-2]
distributed.tests.test_profile ‑ test_info_frame_f_lineno[25-2]
distributed.tests.test_profile ‑ test_info_frame_f_lineno[26-2]
distributed.tests.test_profile ‑ test_info_frame_f_lineno[27-2]
distributed.tests.test_profile ‑ test_merge
distributed.tests.test_profile ‑ test_merge_empty
distributed.tests.test_profile ‑ test_stack_overflow
distributed.tests.test_profile ‑ test_watch
distributed.tests.test_profile ‑ test_watch_requires_lock_to_run
distributed.tests.test_publish ‑ test_datasets_async
distributed.tests.test_publish ‑ test_datasets_contains
distributed.tests.test_publish ‑ test_datasets_delitem
distributed.tests.test_publish ‑ test_datasets_getitem
distributed.tests.test_publish ‑ test_datasets_getitem_default
distributed.tests.test_publish ‑ test_datasets_iter
distributed.tests.test_publish ‑ test_datasets_keys
distributed.tests.test_publish ‑ test_datasets_republish
distributed.tests.test_publish ‑ test_datasets_setitem
distributed.tests.test_publish ‑ test_deserialize_client
distributed.tests.test_publish ‑ test_pickle_safe
distributed.tests.test_publish ‑ test_publish_bag
distributed.tests.test_publish ‑ test_publish_multiple_datasets
distributed.tests.test_publish ‑ test_publish_non_string_key
distributed.tests.test_publish ‑ test_publish_roundtrip
distributed.tests.test_publish ‑ test_publish_simple
distributed.tests.test_publish ‑ test_publish_submit_ordering
distributed.tests.test_publish ‑ test_unpublish
distributed.tests.test_publish ‑ test_unpublish_multiple_datasets_sync
distributed.tests.test_publish ‑ test_unpublish_sync
distributed.tests.test_pubsub ‑ test_basic
distributed.tests.test_pubsub ‑ test_client
distributed.tests.test_pubsub ‑ test_client_worker
distributed.tests.test_pubsub ‑ test_repr
distributed.tests.test_pubsub ‑ test_speed
distributed.tests.test_pubsub ‑ test_timeouts
distributed.tests.test_queues ‑ test_2220
distributed.tests.test_queues ‑ test_Future_knows_status_immediately
distributed.tests.test_queues ‑ test_close
distributed.tests.test_queues ‑ test_erred_future
distributed.tests.test_queues ‑ test_get_many
distributed.tests.test_queues ‑ test_hold_futures
distributed.tests.test_queues ‑ test_picklability
distributed.tests.test_queues ‑ test_picklability_sync
distributed.tests.test_queues ‑ test_queue
distributed.tests.test_queues ‑ test_queue_in_task
distributed.tests.test_queues ‑ test_queue_with_data
distributed.tests.test_queues ‑ test_race
distributed.tests.test_queues ‑ test_same_futures
distributed.tests.test_queues ‑ test_set_cancelled_future
distributed.tests.test_queues ‑ test_sync
distributed.tests.test_queues ‑ test_timeout
distributed.tests.test_queues ‑ test_unpickle_without_client
distributed.tests.test_reschedule ‑ test_cancelled_reschedule[executing]
distributed.tests.test_reschedule ‑ test_cancelled_reschedule[long-running]
distributed.tests.test_reschedule ‑ test_cancelled_reschedule_worker_state[executing]
distributed.tests.test_reschedule ‑ test_cancelled_reschedule_worker_state[long-running]
distributed.tests.test_reschedule ‑ test_raise_reschedule[executing]
distributed.tests.test_reschedule ‑ test_raise_reschedule[long-running]
distributed.tests.test_reschedule ‑ test_reschedule_cancelled[executing]
distributed.tests.test_reschedule ‑ test_reschedule_cancelled[long-running]
distributed.tests.test_reschedule ‑ test_reschedule_releases[executing]
distributed.tests.test_reschedule ‑ test_reschedule_releases[long-running]
distributed.tests.test_reschedule ‑ test_reschedule_resumed[executing]
distributed.tests.test_reschedule ‑ test_reschedule_resumed[long-running]
distributed.tests.test_reschedule ‑ test_scheduler_reschedule_warns
distributed.tests.test_resources ‑ test_balance_resources
distributed.tests.test_resources ‑ test_cancelled_with_resources[executing-ExecuteFailureEvent]
distributed.tests.test_resources ‑ test_cancelled_with_resources[executing-ExecuteSuccessEvent]
distributed.tests.test_resources ‑ test_cancelled_with_resources[executing-RescheduleEvent]
distributed.tests.test_resources ‑ test_cancelled_with_resources[long-running-ExecuteFailureEvent]
distributed.tests.test_resources ‑ test_cancelled_with_resources[long-running-ExecuteSuccessEvent]
distributed.tests.test_resources ‑ test_cancelled_with_resources[long-running-RescheduleEvent]
distributed.tests.test_resources ‑ test_collections_get[False]
distributed.tests.test_resources ‑ test_collections_get[True]
distributed.tests.test_resources ‑ test_compute
distributed.tests.test_resources ‑ test_constrained_tasks_respect_priority
distributed.tests.test_resources ‑ test_constrained_vs_ready_priority_1[0-1-x-False]
distributed.tests.test_resources ‑ test_constrained_vs_ready_priority_1[0-1-x-True]
distributed.tests.test_resources ‑ test_constrained_vs_ready_priority_1[1-0-y-False]
distributed.tests.test_resources ‑ test_constrained_vs_ready_priority_1[1-0-y-True]
distributed.tests.test_resources ‑ test_constrained_vs_ready_priority_2[0-1-x-False]
distributed.tests.test_resources ‑ test_constrained_vs_ready_priority_2[0-1-x-True]
distributed.tests.test_resources ‑ test_constrained_vs_ready_priority_2[1-0-y-False]
distributed.tests.test_resources ‑ test_constrained_vs_ready_priority_2[1-0-y-True]
distributed.tests.test_resources ‑ test_dont_optimize_out
distributed.tests.test_resources ‑ test_dont_work_steal
distributed.tests.test_resources ‑ test_full_collections
distributed.tests.test_resources ‑ test_get
distributed.tests.test_resources ‑ test_map
distributed.tests.test_resources ‑ test_minimum_resource
distributed.tests.test_resources ‑ test_move
distributed.tests.test_resources ‑ test_persist
distributed.tests.test_resources ‑ test_persist_collections
distributed.tests.test_resources ‑ test_persist_multiple_collections
distributed.tests.test_resources ‑ test_resource_submit
distributed.tests.test_resources ‑ test_resources_from_config
distributed.tests.test_resources ‑ test_resources_from_python_override_config
distributed.tests.test_resources ‑ test_resources_str
distributed.tests.test_resources ‑ test_resumed_with_different_resources[executing-ExecuteFailureEvent]
distributed.tests.test_resources ‑ test_resumed_with_different_resources[executing-ExecuteSuccessEvent]
distributed.tests.test_resources ‑ test_resumed_with_different_resources[executing-RescheduleEvent]
distributed.tests.test_resources ‑ test_resumed_with_different_resources[long-running-ExecuteFailureEvent]
distributed.tests.test_resources ‑ test_resumed_with_different_resources[long-running-ExecuteSuccessEvent]
distributed.tests.test_resources ‑ test_resumed_with_different_resources[long-running-RescheduleEvent]
distributed.tests.test_resources ‑ test_resumed_with_resources[executing-ExecuteFailureEvent]
distributed.tests.test_resources ‑ test_resumed_with_resources[executing-ExecuteSuccessEvent]
distributed.tests.test_resources ‑ test_resumed_with_resources[executing-RescheduleEvent]
distributed.tests.test_resources ‑ test_resumed_with_resources[long-running-ExecuteFailureEvent]
distributed.tests.test_resources ‑ test_resumed_with_resources[long-running-ExecuteSuccessEvent]
distributed.tests.test_resources ‑ test_resumed_with_resources[long-running-RescheduleEvent]
distributed.tests.test_resources ‑ test_set_resources
distributed.tests.test_resources ‑ test_submit_many_non_overlapping
distributed.tests.test_resources ‑ test_submit_many_non_overlapping_2
distributed.tests.test_resources ‑ test_task_cancelled_and_readded_with_resources
distributed.tests.test_scheduler ‑ test_KilledWorker_informative_message
distributed.tests.test_scheduler ‑ test_Scheduler__to_dict
distributed.tests.test_scheduler ‑ test_TaskState__to_dict
distributed.tests.test_scheduler ‑ test_adaptive_target
distributed.tests.test_scheduler ‑ test_adaptive_target_empty_cluster[False]
distributed.tests.test_scheduler ‑ test_adaptive_target_empty_cluster[True]
distributed.tests.test_scheduler ‑ test_add_worker
distributed.tests.test_scheduler ‑ test_administration
distributed.tests.test_scheduler ‑ test_alias_resolving_break_queuing
distributed.tests.test_scheduler ‑ test_allow_pickle_false
distributed.tests.test_scheduler ‑ test_allowed_failures_config
distributed.tests.test_scheduler ‑ test_async_context_manager
distributed.tests.test_scheduler ‑ test_avoid_paused_workers
distributed.tests.test_scheduler ‑ test_bad_saturation_factor
distributed.tests.test_scheduler ‑ test_balance_many_workers
distributed.tests.test_scheduler ‑ test_balance_many_workers_2
distributed.tests.test_scheduler ‑ test_balance_with_restrictions
distributed.tests.test_scheduler ‑ test_bandwidth
distributed.tests.test_scheduler ‑ test_bandwidth_clear
distributed.tests.test_scheduler ‑ test_blocked_handlers_are_respected
distributed.tests.test_scheduler ‑ test_broadcast
distributed.tests.test_scheduler ‑ test_broadcast_deprecation
distributed.tests.test_scheduler ‑ test_broadcast_nanny
distributed.tests.test_scheduler ‑ test_broadcast_on_error
distributed.tests.test_scheduler ‑ test_broadcast_tls
distributed.tests.test_scheduler ‑ test_cancel_fire_and_forget
distributed.tests.test_scheduler ‑ test_clear_events_client_removal
distributed.tests.test_scheduler ‑ test_clear_events_worker_removal
distributed.tests.test_scheduler ‑ test_close_nanny
distributed.tests.test_scheduler ‑ test_close_scheduler__close_workers_Nanny
distributed.tests.test_scheduler ‑ test_close_scheduler__close_workers_Worker
distributed.tests.test_scheduler ‑ test_close_worker
distributed.tests.test_scheduler ‑ test_close_workers
distributed.tests.test_scheduler ‑ test_closing_scheduler_closes_workers
distributed.tests.test_scheduler ‑ test_coerce_address
distributed.tests.test_scheduler ‑ test_collect_versions
distributed.tests.test_scheduler ‑ test_concurrent_close_requests
distributed.tests.test_scheduler ‑ test_config_no_stealing
distributed.tests.test_scheduler ‑ test_config_stealing
distributed.tests.test_scheduler ‑ test_count_task_prefix
distributed.tests.test_scheduler ‑ test_dashboard_address
distributed.tests.test_scheduler ‑ test_dashboard_host[127.0.0.1:0-expect1-tcp://0.0.0.0]
distributed.tests.test_scheduler ‑ test_dashboard_host[127.0.0.1:0-expect1-tcp://127.0.0.1:38275]
distributed.tests.test_scheduler ‑ test_dashboard_host[127.0.0.1:0-expect1-tcp://127.0.0.1]
distributed.tests.test_scheduler ‑ test_dashboard_host[None-expect0-tcp://0.0.0.0]
distributed.tests.test_scheduler ‑ test_dashboard_host[None-expect0-tcp://127.0.0.1:38275]
distributed.tests.test_scheduler ‑ test_dashboard_host[None-expect0-tcp://127.0.0.1]
distributed.tests.test_scheduler ‑ test_deadlock_dependency_of_queued_released_when_worker_removed[False]
distributed.tests.test_scheduler ‑ test_deadlock_dependency_of_queued_released_when_worker_removed[True]
distributed.tests.test_scheduler ‑ test_deadlock_dependency_of_queued_released_when_worker_replaced[False]
distributed.tests.test_scheduler ‑ test_deadlock_dependency_of_queued_released_when_worker_replaced[True]
distributed.tests.test_scheduler ‑ test_deadlock_resubmit_queued_tasks_fast[False]
distributed.tests.test_scheduler ‑ test_deadlock_resubmit_queued_tasks_fast[True]
distributed.tests.test_scheduler ‑ test_decide_worker_coschedule_order_neighbors[nthreads0-0]
distributed.tests.test_scheduler ‑ test_decide_worker_coschedule_order_neighbors[nthreads0-1]
distributed.tests.test_scheduler ‑ test_decide_worker_coschedule_order_neighbors[nthreads0-4]
distributed.tests.test_scheduler ‑ test_decide_worker_coschedule_order_neighbors[nthreads1-0]
distributed.tests.test_scheduler ‑ test_decide_worker_coschedule_order_neighbors[nthreads1-1]
distributed.tests.test_scheduler ‑ test_decide_worker_coschedule_order_neighbors[nthreads1-4]
distributed.tests.test_scheduler ‑ test_decide_worker_rootish_while_last_worker_is_retiring
distributed.tests.test_scheduler ‑ test_decide_worker_with_many_independent_leaves
distributed.tests.test_scheduler ‑ test_decide_worker_with_restrictions
distributed.tests.test_scheduler ‑ test_default_task_duration_splits
distributed.tests.test_scheduler ‑ test_delete
distributed.tests.test_scheduler ‑ test_delete_data
distributed.tests.test_scheduler ‑ test_delete_worker_data
distributed.tests.test_scheduler ‑ test_delete_worker_data_bad_task[False]
distributed.tests.test_scheduler ‑ test_delete_worker_data_bad_task[True]
distributed.tests.test_scheduler ‑ test_delete_worker_data_bad_worker
distributed.tests.test_scheduler ‑ test_delete_worker_data_double_delete
distributed.tests.test_scheduler ‑ test_deque_handler
distributed.tests.test_scheduler ‑ test_disable_transition_counter_max
distributed.tests.test_scheduler ‑ test_dont_forget_released_keys
distributed.tests.test_scheduler ‑ test_dont_recompute_if_erred
distributed.tests.test_scheduler ‑ test_dont_recompute_if_persisted
distributed.tests.test_scheduler ‑ test_dont_recompute_if_persisted_2
distributed.tests.test_scheduler ‑ test_dont_recompute_if_persisted_3
distributed.tests.test_scheduler ‑ test_dont_recompute_if_persisted_4
distributed.tests.test_scheduler ‑ test_dump_cluster_state[msgpack]
distributed.tests.test_scheduler ‑ test_dump_cluster_state[yaml]
distributed.tests.test_scheduler ‑ test_dumps_function
distributed.tests.test_scheduler ‑ test_ensure_events_dont_include_taskstate_objects
distributed.tests.test_scheduler ‑ test_failing_task_increments_suspicious
distributed.tests.test_scheduler ‑ test_fan_out_pattern_deadlock
distributed.tests.test_scheduler ‑ test_feed
distributed.tests.test_scheduler ‑ test_feed_large_bytestring
distributed.tests.test_scheduler ‑ test_feed_setup_teardown
distributed.tests.test_scheduler ‑ test_fifo_submission
distributed.tests.test_scheduler ‑ test_file_descriptors
distributed.tests.test_scheduler ‑ test_file_descriptors_dont_leak
distributed.tests.test_scheduler ‑ test_finished
distributed.tests.test_scheduler ‑ test_forget_tasks_while_processing
distributed.tests.test_scheduler ‑ test_gather_bad_worker[False]
distributed.tests.test_scheduler ‑ test_gather_bad_worker[True]
distributed.tests.test_scheduler ‑ test_gather_failing_can_recover
distributed.tests.test_scheduler ‑ test_gather_failing_cnn_error
distributed.tests.test_scheduler ‑ test_gather_no_workers
distributed.tests.test_scheduler ‑ test_gather_on_worker
distributed.tests.test_scheduler ‑ test_gather_on_worker_bad_recipient
distributed.tests.test_scheduler ‑ test_gather_on_worker_bad_sender
distributed.tests.test_scheduler ‑ test_gather_on_worker_bad_sender_replicated[False]
distributed.tests.test_scheduler ‑ test_gather_on_worker_bad_sender_replicated[True]
distributed.tests.test_scheduler ‑ test_gather_on_worker_duplicate_task
distributed.tests.test_scheduler ‑ test_gather_on_worker_key_not_on_sender
distributed.tests.test_scheduler ‑ test_gather_on_worker_key_not_on_sender_replicated[False]
distributed.tests.test_scheduler ‑ test_gather_on_worker_key_not_on_sender_replicated[True]
distributed.tests.test_scheduler ‑ test_get_cluster_state
distributed.tests.test_scheduler ‑ test_get_cluster_state_worker_error
distributed.tests.test_scheduler ‑ test_get_task_duration
distributed.tests.test_scheduler ‑ test_get_task_status
distributed.tests.test_scheduler ‑ test_get_worker_monitor_info
distributed.tests.test_scheduler ‑ test_gh2187
distributed.tests.test_scheduler ‑ test_graph_execution_width
distributed.tests.test_scheduler ‑ test_host_address
distributed.tests.test_scheduler ‑ test_html_repr
distributed.tests.test_scheduler ‑ test_idle_during_update_graph
distributed.tests.test_scheduler ‑ test_idle_timeout
distributed.tests.test_scheduler ‑ test_idle_timeout_no_workers
distributed.tests.test_scheduler ‑ test_include_communication_in_occupancy
distributed.tests.test_scheduler ‑ test_infrequent_sysmon
distributed.tests.test_scheduler ‑ test_io_loop
distributed.tests.test_scheduler ‑ test_learn_occupancy
distributed.tests.test_scheduler ‑ test_learn_occupancy_2
distributed.tests.test_scheduler ‑ test_log_tasks_during_restart
distributed.tests.test_scheduler ‑ test_memory
distributed.tests.test_scheduler ‑ test_memory_no_workers
distributed.tests.test_scheduler ‑ test_memory_no_zict
distributed.tests.test_scheduler ‑ test_memorystate
distributed.tests.test_scheduler ‑ test_memorystate__to_dict
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-0-0-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-0-0-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-0-0-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-0-0-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-0-1-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-0-1-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-0-1-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-0-1-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-0-2-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-0-2-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-0-2-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-0-2-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-0-3-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-0-3-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-0-3-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-0-3-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-1-0-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-1-0-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-1-0-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-1-0-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-1-1-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-1-1-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-1-1-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-1-1-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-1-2-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-1-2-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-1-2-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-1-2-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-1-3-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-1-3-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-1-3-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-1-3-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-2-0-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-2-0-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-2-0-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-2-0-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-2-1-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-2-1-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-2-1-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-2-1-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-2-2-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-2-2-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-2-2-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-2-2-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-2-3-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-2-3-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-2-3-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-2-3-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-3-0-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-3-0-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-3-0-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-3-0-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-3-1-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-3-1-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-3-1-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-3-1-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-3-2-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-3-2-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-3-2-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-3-2-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-3-3-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-3-3-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-3-3-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[0-3-3-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-0-0-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-0-0-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-0-0-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-0-0-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-0-1-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-0-1-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-0-1-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-0-1-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-0-2-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-0-2-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-0-2-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-0-2-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-0-3-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-0-3-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-0-3-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-0-3-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-1-0-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-1-0-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-1-0-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-1-0-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-1-1-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-1-1-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-1-1-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-1-1-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-1-2-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-1-2-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-1-2-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-1-2-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-1-3-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-1-3-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-1-3-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-1-3-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-2-0-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-2-0-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-2-0-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-2-0-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-2-1-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-2-1-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-2-1-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-2-1-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-2-2-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-2-2-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-2-2-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-2-2-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-2-3-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-2-3-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-2-3-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-2-3-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-3-0-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-3-0-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-3-0-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-3-0-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-3-1-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-3-1-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-3-1-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-3-1-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-3-2-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-3-2-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-3-2-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-3-2-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-3-3-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-3-3-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-3-3-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[1-3-3-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-0-0-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-0-0-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-0-0-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-0-0-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-0-1-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-0-1-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-0-1-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-0-1-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-0-2-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-0-2-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-0-2-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-0-2-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-0-3-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-0-3-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-0-3-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-0-3-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-1-0-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-1-0-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-1-0-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-1-0-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-1-1-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-1-1-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-1-1-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-1-1-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-1-2-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-1-2-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-1-2-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-1-2-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-1-3-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-1-3-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-1-3-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-1-3-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-2-0-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-2-0-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-2-0-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-2-0-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-2-1-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-2-1-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-2-1-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-2-1-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-2-2-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-2-2-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-2-2-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-2-2-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-2-3-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-2-3-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-2-3-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-2-3-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-3-0-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-3-0-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-3-0-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-3-0-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-3-1-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-3-1-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-3-1-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-3-1-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-3-2-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-3-2-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-3-2-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-3-2-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-3-3-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-3-3-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-3-3-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[2-3-3-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-0-0-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-0-0-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-0-0-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-0-0-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-0-1-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-0-1-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-0-1-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-0-1-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-0-2-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-0-2-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-0-2-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-0-2-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-0-3-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-0-3-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-0-3-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-0-3-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-1-0-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-1-0-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-1-0-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-1-0-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-1-1-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-1-1-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-1-1-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-1-1-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-1-2-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-1-2-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-1-2-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-1-2-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-1-3-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-1-3-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-1-3-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-1-3-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-2-0-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-2-0-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-2-0-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-2-0-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-2-1-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-2-1-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-2-1-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-2-1-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-2-2-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-2-2-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-2-2-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-2-2-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-2-3-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-2-3-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-2-3-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-2-3-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-3-0-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-3-0-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-3-0-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-3-0-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-3-1-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-3-1-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-3-1-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-3-1-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-3-2-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-3-2-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-3-2-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-3-2-3]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-3-3-0]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-3-3-1]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-3-3-2]
distributed.tests.test_scheduler ‑ test_memorystate_adds_up[3-3-3-3]
distributed.tests.test_scheduler ‑ test_memorystate_sum
distributed.tests.test_scheduler ‑ test_missing_data_errant_worker
distributed.tests.test_scheduler ‑ test_move_data_over_break_restrictions
distributed.tests.test_scheduler ‑ test_multiple_listeners[{ENV_VAR_MISSING}-dashboard at:\\s*:\\d*]
distributed.tests.test_scheduler ‑ test_multiple_listeners[{scheme}://{host}:{port}/status-dashboard at:\\s*http://]
distributed.tests.test_scheduler ‑ test_no_dangling_asyncio_tasks
distributed.tests.test_scheduler ‑ test_no_valid_workers
distributed.tests.test_scheduler ‑ test_no_valid_workers_loose_restrictions
distributed.tests.test_scheduler ‑ test_no_workers[False]
distributed.tests.test_scheduler ‑ test_no_workers[True]
distributed.tests.test_scheduler ‑ test_no_workers_timeout_bad_restrictions
distributed.tests.test_scheduler ‑ test_no_workers_timeout_disabled
distributed.tests.test_scheduler ‑ test_no_workers_timeout_processing
distributed.tests.test_scheduler ‑ test_no_workers_timeout_queued
distributed.tests.test_scheduler ‑ test_no_workers_timeout_without_workers
distributed.tests.test_scheduler ‑ test_nonempty_data_is_rejected
distributed.tests.test_scheduler ‑ test_profile_metadata
distributed.tests.test_scheduler ‑ test_profile_metadata_keys
distributed.tests.test_scheduler ‑ test_profile_metadata_timeout
distributed.tests.test_scheduler ‑ test_queued_paused_new_worker
distributed.tests.test_scheduler ‑ test_queued_paused_unpaused[False]
distributed.tests.test_scheduler ‑ test_queued_paused_unpaused[True]
distributed.tests.test_scheduler ‑ test_queued_release_multiple_workers
distributed.tests.test_scheduler ‑ test_queued_remove_add_worker
distributed.tests.test_scheduler ‑ test_quiet_cluster_round_robin
distributed.tests.test_scheduler ‑ test_ready_remove_worker[1.0]
distributed.tests.test_scheduler ‑ test_ready_remove_worker[inf]
distributed.tests.test_scheduler ‑ test_rebalance
distributed.tests.test_scheduler ‑ test_rebalance_dead_recipient
distributed.tests.test_scheduler ‑ test_rebalance_least_recently_inserted_sender_min
distributed.tests.test_scheduler ‑ test_rebalance_managed_memory
distributed.tests.test_scheduler ‑ test_rebalance_missing_data1
distributed.tests.test_scheduler ‑ test_rebalance_missing_data2
distributed.tests.test_scheduler ‑ test_rebalance_no_limit
distributed.tests.test_scheduler ‑ test_rebalance_no_recipients
distributed.tests.test_scheduler ‑ test_rebalance_no_workers
distributed.tests.test_scheduler ‑ test_rebalance_raises_missing_data3[False]
distributed.tests.test_scheduler ‑ test_rebalance_raises_missing_data3[True]
distributed.tests.test_scheduler ‑ test_rebalance_sender_below_mean
distributed.tests.test_scheduler ‑ test_rebalance_skip_all_recipients
distributed.tests.test_scheduler ‑ test_rebalance_skip_recipient
distributed.tests.test_scheduler ‑ test_rebalance_workers_and_keys
distributed.tests.test_scheduler ‑ test_recompute_released_results
distributed.tests.test_scheduler ‑ test_refuse_to_schedule_huge_task[False]
distributed.tests.test_scheduler ‑ test_refuse_to_schedule_huge_task[True]
distributed.tests.test_scheduler ‑ test_remove_worker_by_name_from_scheduler
distributed.tests.test_scheduler ‑ test_remove_worker_from_scheduler
distributed.tests.test_scheduler ‑ test_remove_worker_from_scheduler_warns_on_safe
distributed.tests.test_scheduler ‑ test_repr
distributed.tests.test_scheduler ‑ test_resources_reset_after_cancelled_task
distributed.tests.test_scheduler ‑ test_respect_data_in_memory
distributed.tests.test_scheduler ‑ test_restart
distributed.tests.test_scheduler ‑ test_restart_heartbeat_before_closing
distributed.tests.test_scheduler ‑ test_restart_nanny_timeout_exceeded
distributed.tests.test_scheduler ‑ test_restart_no_wait_for_workers
distributed.tests.test_scheduler ‑ test_restart_not_all_workers_return
distributed.tests.test_scheduler ‑ test_restart_some_nannies_some_not
distributed.tests.test_scheduler ‑ test_restart_waits_for_new_workers
distributed.tests.test_scheduler ‑ test_restart_while_processing
distributed.tests.test_scheduler ‑ test_restart_worker_rejoins_after_timeout_expired
distributed.tests.test_scheduler ‑ test_resubmit_different_task_same_key_after_previous_is_done[False-less]
distributed.tests.test_scheduler ‑ test_resubmit_different_task_same_key_after_previous_is_done[False-more]
distributed.tests.test_scheduler ‑ test_resubmit_different_task_same_key_after_previous_is_done[False-same]
distributed.tests.test_scheduler ‑ test_resubmit_different_task_same_key_after_previous_is_done[True-less]
distributed.tests.test_scheduler ‑ test_resubmit_different_task_same_key_after_previous_is_done[True-more]
distributed.tests.test_scheduler ‑ test_resubmit_different_task_same_key_after_previous_is_done[True-same]
distributed.tests.test_scheduler ‑ test_resubmit_different_task_same_key_before_previous_is_done[less]
distributed.tests.test_scheduler ‑ test_resubmit_different_task_same_key_before_previous_is_done[more]
distributed.tests.test_scheduler ‑ test_resubmit_different_task_same_key_before_previous_is_done[same]
distributed.tests.test_scheduler ‑ test_resubmit_different_task_same_key_many_clients
distributed.tests.test_scheduler ‑ test_resubmit_different_task_same_key_warns_only_once[10-2]
distributed.tests.test_scheduler ‑ test_resubmit_different_task_same_key_warns_only_once[30-1]
distributed.tests.test_scheduler ‑ test_resubmit_nondeterministic_task_different_deps[False]
distributed.tests.test_scheduler ‑ test_resubmit_nondeterministic_task_different_deps[True]
distributed.tests.test_scheduler ‑ test_resubmit_nondeterministic_task_same_deps[123-after1-True]
distributed.tests.test_scheduler ‑ test_resubmit_nondeterministic_task_same_deps[before0-123-True]
distributed.tests.test_scheduler ‑ test_resubmit_nondeterministic_task_same_deps[before2-after2-False]
distributed.tests.test_scheduler ‑ test_result_type
distributed.tests.test_scheduler ‑ test_retire_names_str
distributed.tests.test_scheduler ‑ test_retire_nannies_close
distributed.tests.test_scheduler ‑ test_retire_state_change
distributed.tests.test_scheduler ‑ test_retire_workers
distributed.tests.test_scheduler ‑ test_retire_workers_bad_params
distributed.tests.test_scheduler ‑ test_retire_workers_close
distributed.tests.test_scheduler ‑ test_retire_workers_concurrently
distributed.tests.test_scheduler ‑ test_retire_workers_empty
distributed.tests.test_scheduler ‑ test_retire_workers_lock
distributed.tests.test_scheduler ‑ test_retire_workers_n
distributed.tests.test_scheduler ‑ test_retire_workers_no_suspicious_tasks
distributed.tests.test_scheduler ‑ test_retries
distributed.tests.test_scheduler ‑ test_rootish_taskgroup_configuration
distributed.tests.test_scheduler ‑ test_run_on_scheduler
distributed.tests.test_scheduler ‑ test_run_on_scheduler_sync
distributed.tests.test_scheduler ‑ test_runspec_regression_sync
distributed.tests.test_scheduler ‑ test_saturation_factor[0.1-expected_task_counts4]
distributed.tests.test_scheduler ‑ test_saturation_factor[1.0-expected_task_counts3]
distributed.tests.test_scheduler ‑ test_saturation_factor[1.1-expected_task_counts2]
distributed.tests.test_scheduler ‑ test_saturation_factor[2.0-expected_task_counts1]
distributed.tests.test_scheduler ‑ test_saturation_factor[2.5-expected_task_counts0]
distributed.tests.test_scheduler ‑ test_saturation_factor[inf-expected_task_counts5]
distributed.tests.test_scheduler ‑ test_saturation_factor[inf-expected_task_counts6]
distributed.tests.test_scheduler ‑ test_scatter_creates_ts
distributed.tests.test_scheduler ‑ test_scatter_no_workers[False]
distributed.tests.test_scheduler ‑ test_scatter_no_workers[True]
distributed.tests.test_scheduler ‑ test_scheduler_close_fast_deprecated
distributed.tests.test_scheduler ‑ test_scheduler_file
distributed.tests.test_scheduler ‑ test_scheduler_init_pulls_blocked_handlers_from_config
distributed.tests.test_scheduler ‑ test_scheduler_sees_memory_limits
distributed.tests.test_scheduler ‑ test_secede_opens_slot
distributed.tests.test_scheduler ‑ test_server_listens_to_other_ops
distributed.tests.test_scheduler ‑ test_set_restrictions
distributed.tests.test_scheduler ‑ test_statistical_profiling
distributed.tests.test_scheduler ‑ test_statistical_profiling_failure
distributed.tests.test_scheduler ‑ test_stimulus_from_erred_task
distributed.tests.test_scheduler ‑ test_story
distributed.tests.test_scheduler ‑ test_submit_dependency_of_erred_task
distributed.tests.test_scheduler ‑ test_task_group_and_prefix_statistics
distributed.tests.test_scheduler ‑ test_task_group_done
distributed.tests.test_scheduler ‑ test_task_group_non_tuple_key
distributed.tests.test_scheduler ‑ test_task_group_not_done_noworker
distributed.tests.test_scheduler ‑ test_task_group_not_done_processing
distributed.tests.test_scheduler ‑ test_task_group_not_done_queued
distributed.tests.test_scheduler ‑ test_task_group_not_done_waiting
distributed.tests.test_scheduler ‑ test_task_group_on_fire_and_forget
distributed.tests.test_scheduler ‑ test_task_groups_update_start_stop
distributed.tests.test_scheduler ‑ test_task_prefix
distributed.tests.test_scheduler ‑ test_task_unique_groups
distributed.tests.test_scheduler ‑ test_tell_workers_when_peers_have_left
distributed.tests.test_scheduler ‑ test_too_many_groups
distributed.tests.test_scheduler ‑ test_transition_counter
distributed.tests.test_scheduler ‑ test_transition_counter_max_scheduler
distributed.tests.test_scheduler ‑ test_transition_counter_max_worker
distributed.tests.test_scheduler ‑ test_transition_failure_triggers_log_event
distributed.tests.test_scheduler ‑ test_transition_waiting_memory
distributed.tests.test_scheduler ‑ test_unknown_task_duration_config
distributed.tests.test_scheduler ‑ test_unknown_task_duration_config_2
distributed.tests.test_scheduler ‑ test_update_graph_culls
distributed.tests.test_scheduler ‑ test_worker_arrives_with_data_is_rejected
distributed.tests.test_scheduler ‑ test_worker_heartbeat_after_cancel
distributed.tests.test_scheduler ‑ test_worker_name
distributed.tests.test_scheduler ‑ test_worker_name_collision
distributed.tests.test_scheduler ‑ test_worker_state_unique_regardless_of_address
distributed.tests.test_scheduler ‑ test_workers_to_close
distributed.tests.test_scheduler ‑ test_workers_to_close_grouped
distributed.tests.test_scheduler ‑ test_workers_to_close_never_close_long_running[False]
distributed.tests.test_scheduler ‑ test_workers_to_close_never_close_long_running[True]
distributed.tests.test_scheduler ‑ test_workerstate_clean
distributed.tests.test_security ‑ test_attribute_error
distributed.tests.test_security ‑ test_connection_args
distributed.tests.test_security ‑ test_constructor_errors
distributed.tests.test_security ‑ test_defaults
distributed.tests.test_security ‑ test_extra_conn_args_connection_args
distributed.tests.test_security ‑ test_extra_conn_args_in_temporary_credentials
distributed.tests.test_security ‑ test_from_config
distributed.tests.test_security ‑ test_invalid_min_version_from_config_errors
distributed.tests.test_security ‑ test_kwargs
distributed.tests.test_security ‑ test_listen_args
distributed.tests.test_security ‑ test_min_max_version_config_errors[max-version]
distributed.tests.test_security ‑ test_min_max_version_config_errors[min-version]
distributed.tests.test_security ‑ test_min_max_version_from_config[1.2-1.2]
distributed.tests.test_security ‑ test_min_max_version_from_config[1.2-1.3]
distributed.tests.test_security ‑ test_min_max_version_from_config[1.2-None]
distributed.tests.test_security ‑ test_min_max_version_from_config[1.3-1.2]
distributed.tests.test_security ‑ test_min_max_version_from_config[1.3-1.3]
distributed.tests.test_security ‑ test_min_max_version_from_config[1.3-None]
distributed.tests.test_security ‑ test_min_max_version_from_config[None-1.2]
distributed.tests.test_security ‑ test_min_max_version_from_config[None-1.3]
distributed.tests.test_security ‑ test_min_max_version_from_config[None-None]
distributed.tests.test_security ‑ test_min_max_version_kwarg_errors[tls_max_version]
distributed.tests.test_security ‑ test_min_max_version_kwarg_errors[tls_min_version]
distributed.tests.test_security ‑ test_repr_local_keys
distributed.tests.test_security ‑ test_repr_temp_keys
distributed.tests.test_security ‑ test_require_encryption
distributed.tests.test_security ‑ test_temporary_credentials
distributed.tests.test_security ‑ test_tls_config_for_role
distributed.tests.test_security ‑ test_tls_listen_connect
distributed.tests.test_security ‑ test_tls_temporary_credentials_functional
distributed.tests.test_semaphore ‑ test_access_semaphore_by_name
distributed.tests.test_semaphore ‑ test_acquires_with_timeout
distributed.tests.test_semaphore ‑ test_async_ctx
distributed.tests.test_semaphore ‑ test_close_async
distributed.tests.test_semaphore ‑ test_getvalue
distributed.tests.test_semaphore ‑ test_metrics
distributed.tests.test_semaphore ‑ test_oversubscribing_leases
distributed.tests.test_semaphore ‑ test_release_failure
distributed.tests.test_semaphore ‑ test_release_once_too_many
distributed.tests.test_semaphore ‑ test_release_once_too_many_resilience
distributed.tests.test_semaphore ‑ test_release_retry
distributed.tests.test_semaphore ‑ test_release_semaphore_after_timeout
distributed.tests.test_semaphore ‑ test_release_simple
distributed.tests.test_semaphore ‑ test_retry_acquire
distributed.tests.test_semaphore ‑ test_semaphore_trivial
distributed.tests.test_semaphore ‑ test_serializable
distributed.tests.test_semaphore ‑ test_threadpoolworkers_pick_correct_ioloop
distributed.tests.test_semaphore ‑ test_timeout_sync
distributed.tests.test_semaphore ‑ test_timeout_zero
distributed.tests.test_semaphore ‑ test_unpickle_without_client
distributed.tests.test_semaphore ‑ test_worker_dies
distributed.tests.test_sizeof ‑ test_safe_sizeof[obj0]
distributed.tests.test_sizeof ‑ test_safe_sizeof[obj1]
distributed.tests.test_sizeof ‑ test_safe_sizeof[obj2]
distributed.tests.test_sizeof ‑ test_safe_sizeof_logs_on_failure
distributed.tests.test_spans ‑ test_active_cpu_seconds_change_nthreads
distributed.tests.test_spans ‑ test_active_cpu_seconds_merged
distributed.tests.test_spans ‑ test_active_cpu_seconds_not_done[False]
distributed.tests.test_spans ‑ test_active_cpu_seconds_not_done[True]
distributed.tests.test_spans ‑ test_active_cpu_seconds_trivial
distributed.tests.test_spans ‑ test_before_first_task_finished
distributed.tests.test_spans ‑ test_code
distributed.tests.test_spans ‑ test_collections_metadata
distributed.tests.test_spans ‑ test_default_span
distributed.tests.test_spans ‑ test_duplicate_task_group
distributed.tests.test_spans ‑ test_merge_all
distributed.tests.test_spans ‑ test_merge_by_tags
distributed.tests.test_spans ‑ test_merge_by_tags_metrics
distributed.tests.test_spans ‑ test_merge_nothing
distributed.tests.test_spans ‑ test_mismatched_span[False]
distributed.tests.test_spans ‑ test_mismatched_span[True]
distributed.tests.test_spans ‑ test_multiple_tags
distributed.tests.test_spans ‑ test_no_code_by_default
distributed.tests.test_spans ‑ test_no_extension
distributed.tests.test_spans ‑ test_no_tags
distributed.tests.test_spans ‑ test_repeat_span
distributed.tests.test_spans ‑ test_scatter_creates_tg
distributed.tests.test_spans ‑ test_scatter_creates_ts
distributed.tests.test_spans ‑ test_span_on_persist
distributed.tests.test_spans ‑ test_spans
distributed.tests.test_spans ‑ test_spans_are_visible_from_tasks
distributed.tests.test_spans ‑ test_submit
distributed.tests.test_spans ‑ test_task_groups[False]
distributed.tests.test_spans ‑ test_task_groups[True]
distributed.tests.test_spans ‑ test_worker_metrics
distributed.tests.test_spec ‑ test_address_default_none
distributed.tests.test_spec ‑ test_child_address_persists
distributed.tests.test_spill ‑ test_compression_settings[None-20000-20500]
distributed.tests.test_spill ‑ test_compression_settings[zlib-100-500]
distributed.tests.test_spill ‑ test_disk_size_calculation
distributed.tests.test_spill ‑ test_metrics
distributed.tests.test_spill ‑ test_no_pop
distributed.tests.test_spill ‑ test_psize
distributed.tests.test_spill ‑ test_spillbuffer
distributed.tests.test_spill ‑ test_spillbuffer_evict
distributed.tests.test_spill ‑ test_spillbuffer_fail_to_serialize
distributed.tests.test_spill ‑ test_spillbuffer_maxlim
distributed.tests.test_spill ‑ test_spillbuffer_oserror
distributed.tests.test_spill ‑ test_str_collision
distributed.tests.test_spill ‑ test_weakref_cache[110-NoWeakRef-False]
distributed.tests.test_spill ‑ test_weakref_cache[110-SupportsWeakRef-True]
distributed.tests.test_spill ‑ test_weakref_cache[60-NoWeakRef-False]
distributed.tests.test_spill ‑ test_weakref_cache[60-SupportsWeakRef-True]
distributed.tests.test_steal ‑ test_allow_tasks_stolen_before_first_completes
distributed.tests.test_steal ‑ test_balance[balance even if results in even]
distributed.tests.test_steal ‑ test_balance[balance multiple saturated workers]
distributed.tests.test_steal ‑ test_balance[balance]
distributed.tests.test_steal ‑ test_balance[be willing to move costly items]
distributed.tests.test_steal ‑ test_balance[but don't move too many]
distributed.tests.test_steal ‑ test_balance[choose easier first]
distributed.tests.test_steal ‑ test_balance[don't move unnecessarily]
distributed.tests.test_steal ‑ test_balance[don't over balance]
distributed.tests.test_steal ‑ test_balance[move easier]
distributed.tests.test_steal ‑ test_balance[move from larger]
distributed.tests.test_steal ‑ test_balance[move to smaller]
distributed.tests.test_steal ‑ test_balance[no one clearly saturated]
distributed.tests.test_steal ‑ test_balance[spread evenly]
distributed.tests.test_steal ‑ test_balance_even_with_replica
distributed.tests.test_steal ‑ test_balance_eventually_steals_large_dependency_without_replica
distributed.tests.test_steal ‑ test_balance_expensive_tasks[enough work to steal]
distributed.tests.test_steal ‑ test_balance_expensive_tasks[not enough work for increased cost]
distributed.tests.test_steal ‑ test_balance_expensive_tasks[not enough work to steal]
distributed.tests.test_steal ‑ test_balance_multiple_to_replica
distributed.tests.test_steal ‑ test_balance_prefers_busier_with_dependency
distributed.tests.test_steal ‑ test_balance_to_larger_dependency
distributed.tests.test_steal ‑ test_balance_to_replica
distributed.tests.test_steal ‑ test_balance_uneven_without_replica
distributed.tests.test_steal ‑ test_balance_with_longer_task
distributed.tests.test_steal ‑ test_balance_without_dependencies
distributed.tests.test_steal ‑ test_blocklist_shuffle_split
distributed.tests.test_steal ‑ test_cleanup_repeated_tasks
distributed.tests.test_steal ‑ test_correct_bad_time_estimate
distributed.tests.test_steal ‑ test_dont_steal_already_released
distributed.tests.test_steal ‑ test_dont_steal_executing_tasks
distributed.tests.test_steal ‑ test_dont_steal_executing_tasks_2
distributed.tests.test_steal ‑ test_dont_steal_expensive_data_fast_computation
distributed.tests.test_steal ‑ test_dont_steal_fast_tasks_blocklist
distributed.tests.test_steal ‑ test_dont_steal_fast_tasks_compute_time
distributed.tests.test_steal ‑ test_dont_steal_few_saturated_tasks_many_workers
distributed.tests.test_steal ‑ test_dont_steal_host_restrictions
distributed.tests.test_steal ‑ test_dont_steal_long_running_tasks
distributed.tests.test_steal ‑ test_dont_steal_resource_restrictions
distributed.tests.test_steal ‑ test_dont_steal_worker_restrictions
distributed.tests.test_steal ‑ test_eventually_steal_unknown_functions
distributed.tests.test_steal ‑ test_get_story
distributed.tests.test_steal ‑ test_lose_task
distributed.tests.test_steal ‑ test_new_worker_steals
distributed.tests.test_steal ‑ test_parse_stealing_interval[2-2]
distributed.tests.test_steal ‑ test_parse_stealing_interval[500ms-500]
distributed.tests.test_steal ‑ test_parse_stealing_interval[None-100]
distributed.tests.test_steal ‑ test_paused_workers_must_not_steal
distributed.tests.test_steal ‑ test_reschedule_concurrent_requests_deadlock
distributed.tests.test_steal ‑ test_restart
distributed.tests.test_steal ‑ test_steal_cheap_data_slow_computation
distributed.tests.test_steal ‑ test_steal_concurrent_simple
distributed.tests.test_steal ‑ test_steal_expensive_data_slow_computation
distributed.tests.test_steal ‑ test_steal_host_restrictions
distributed.tests.test_steal ‑ test_steal_more_attractive_tasks
distributed.tests.test_steal ‑ test_steal_related_tasks
distributed.tests.test_steal ‑ test_steal_reschedule_reset_in_flight_occupancy
distributed.tests.test_steal ‑ test_steal_resource_restrictions
distributed.tests.test_steal ‑ test_steal_resource_restrictions_asym_diff
distributed.tests.test_steal ‑ test_steal_stimulus_id_unique
distributed.tests.test_steal ‑ test_steal_twice
distributed.tests.test_steal ‑ test_steal_very_fast_tasks
distributed.tests.test_steal ‑ test_steal_when_more_tasks
distributed.tests.test_steal ‑ test_steal_worker_dies_same_ip
distributed.tests.test_steal ‑ test_steal_worker_restrictions
distributed.tests.test_steal ‑ test_steal_worker_state[executing]
distributed.tests.test_steal ‑ test_steal_worker_state[long-running]
distributed.tests.test_steal ‑ test_stop_in_flight
distributed.tests.test_steal ‑ test_stop_plugin
distributed.tests.test_steal ‑ test_trivial_workload_should_not_cause_work_stealing
distributed.tests.test_steal ‑ test_work_steal_allow_other_workers
distributed.tests.test_steal ‑ test_work_stealing
distributed.tests.test_steal ‑ test_worksteal_many_thieves
distributed.tests.test_stories ‑ test_client_story
distributed.tests.test_stories ‑ test_client_story_failed_worker[ignore]
distributed.tests.test_stories ‑ test_client_story_failed_worker[raise]
distributed.tests.test_stories ‑ test_scheduler_story_stimulus_retry
distributed.tests.test_stories ‑ test_scheduler_story_stimulus_success
distributed.tests.test_stories ‑ test_worker_story_with_deps
distributed.tests.test_stress ‑ test_cancel_stress
distributed.tests.test_stress ‑ test_cancel_stress_sync
distributed.tests.test_stress ‑ test_chaos_rechunk
distributed.tests.test_stress ‑ test_close_connections
distributed.tests.test_stress ‑ test_no_delay_during_large_transfer
distributed.tests.test_stress ‑ test_stress_1
distributed.tests.test_stress ‑ test_stress_creation_and_deletion
distributed.tests.test_stress ‑ test_stress_gc[inc-1000]
distributed.tests.test_stress ‑ test_stress_gc[slowinc-100]
distributed.tests.test_stress ‑ test_stress_scatter_death
distributed.tests.test_stress ‑ test_stress_steal
distributed.tests.test_system ‑ test_hard_memory_limit_cgroups
distributed.tests.test_system ‑ test_hard_memory_limit_cgroups2
distributed.tests.test_system ‑ test_memory_limit
distributed.tests.test_system ‑ test_rlimit
distributed.tests.test_system ‑ test_soft_memory_limit_cgroups
distributed.tests.test_system ‑ test_soft_memory_limit_cgroups2
distributed.tests.test_system ‑ test_softest_memory_limit_cgroups2
distributed.tests.test_system_monitor ‑ test_SystemMonitor
distributed.tests.test_system_monitor ‑ test_count
distributed.tests.test_system_monitor ‑ test_disk_config
distributed.tests.test_system_monitor ‑ test_gil_contention
distributed.tests.test_system_monitor ‑ test_host_cpu
distributed.tests.test_system_monitor ‑ test_maxlen_zero
distributed.tests.test_system_monitor ‑ test_range_query
distributed.tests.test_threadpoolexecutor ‑ test_rejoin_idempotent
distributed.tests.test_threadpoolexecutor ‑ test_secede_rejoin_busy
distributed.tests.test_threadpoolexecutor ‑ test_secede_rejoin_quiet
distributed.tests.test_threadpoolexecutor ‑ test_shutdown_timeout
distributed.tests.test_threadpoolexecutor ‑ test_shutdown_timeout_raises
distributed.tests.test_threadpoolexecutor ‑ test_shutdown_wait
distributed.tests.test_threadpoolexecutor ‑ test_thread_name
distributed.tests.test_threadpoolexecutor ‑ test_tpe
distributed.tests.test_tls_functional ‑ test_Queue
distributed.tests.test_tls_functional ‑ test_basic
distributed.tests.test_tls_functional ‑ test_client_submit
distributed.tests.test_tls_functional ‑ test_gather
distributed.tests.test_tls_functional ‑ test_nanny
distributed.tests.test_tls_functional ‑ test_rebalance
distributed.tests.test_tls_functional ‑ test_retire_workers
distributed.tests.test_tls_functional ‑ test_scatter
distributed.tests.test_tls_functional ‑ test_security_dict_input
distributed.tests.test_tls_functional ‑ test_security_dict_input_no_security
distributed.tests.test_tls_functional ‑ test_work_stealing
distributed.tests.test_tls_functional ‑ test_worker_client
distributed.tests.test_tls_functional ‑ test_worker_client_executor
distributed.tests.test_tls_functional ‑ test_worker_client_gather
distributed.tests.test_utils ‑ test_All
distributed.tests.test_utils ‑ test_all_quiet_exceptions
distributed.tests.test_utils ‑ test_ensure_ip
distributed.tests.test_utils ‑ test_ensure_memoryview[1]
distributed.tests.test_utils ‑ test_ensure_memoryview[]
distributed.tests.test_utils ‑ test_ensure_memoryview[data10]
distributed.tests.test_utils ‑ test_ensure_memoryview[data11]
distributed.tests.test_utils ‑ test_ensure_memoryview[data12]
distributed.tests.test_utils ‑ test_ensure_memoryview[data13]
distributed.tests.test_utils ‑ test_ensure_memoryview[data14]
distributed.tests.test_utils ‑ test_ensure_memoryview[data1]
distributed.tests.test_utils ‑ test_ensure_memoryview[data3]
distributed.tests.test_utils ‑ test_ensure_memoryview[data4]
distributed.tests.test_utils ‑ test_ensure_memoryview[data5]
distributed.tests.test_utils ‑ test_ensure_memoryview[data6]
distributed.tests.test_utils ‑ test_ensure_memoryview[data7]
distributed.tests.test_utils ‑ test_ensure_memoryview[data8]
distributed.tests.test_utils ‑ test_ensure_memoryview[data9]
distributed.tests.test_utils ‑ test_ensure_memoryview_ndarray[i8-12-shape0-strides0]
distributed.tests.test_utils ‑ test_ensure_memoryview_ndarray[i8-12-shape1-strides1]
distributed.tests.test_utils ‑ test_ensure_memoryview_ndarray[i8-12-shape2-strides2]
distributed.tests.test_utils ‑ test_ensure_memoryview_ndarray[i8-12-shape3-strides3]
distributed.tests.test_utils ‑ test_ensure_memoryview_ndarray[i8-12-shape4-strides4]
distributed.tests.test_utils ‑ test_ensure_memoryview_pyarrow_buffer
distributed.tests.test_utils ‑ test_format_dashboard_link
distributed.tests.test_utils ‑ test_get_ip_interface
distributed.tests.test_utils ‑ test_get_mp_context

Check notice on line 0 in .github

See this annotation in the file changed.

@github-actions github-actions / Unit Test Results

4130 tests found (test 3548 to 4130) 

There are 4130 tests, see "Raw output" for the list of tests 3548 to 4130.
Raw output 
distributed.tests.test_utils ‑ test_get_traceback
distributed.tests.test_utils ‑ test_is_kernel
distributed.tests.test_utils ‑ test_is_valid_xml
distributed.tests.test_utils ‑ test_iscoroutinefunction_nested_partial
distributed.tests.test_utils ‑ test_iscoroutinefunction_unhashable_input
distributed.tests.test_utils ‑ test_load_json_robust_timeout
distributed.tests.test_utils ‑ test_log_errors
distributed.tests.test_utils ‑ test_log_errors_unroll_stack[0-test_utils]
distributed.tests.test_utils ‑ test_log_errors_unroll_stack[1-a.b.c]
distributed.tests.test_utils ‑ test_logs
distributed.tests.test_utils ‑ test_loop_runner
distributed.tests.test_utils ‑ test_loop_runner_exception_in_start
distributed.tests.test_utils ‑ test_loop_runner_exception_in_teardown
distributed.tests.test_utils ‑ test_loop_runner_gen
distributed.tests.test_utils ‑ test_nbytes
distributed.tests.test_utils ‑ test_no_default_deprecated
distributed.tests.test_utils ‑ test_offload
distributed.tests.test_utils ‑ test_offload_preserves_contextvars
distributed.tests.test_utils ‑ test_open_port
distributed.tests.test_utils ‑ test_parse_ports
distributed.tests.test_utils ‑ test_rate_limiter_filter
distributed.tests.test_utils ‑ test_read_block
distributed.tests.test_utils ‑ test_recursive_to_dict
distributed.tests.test_utils ‑ test_recursive_to_dict_no_nest
distributed.tests.test_utils ‑ test_run_in_executor_with_context
distributed.tests.test_utils ‑ test_run_in_executor_with_context_preserves_contextvars
distributed.tests.test_utils ‑ test_seek_delimiter_endline
distributed.tests.test_utils ‑ test_set_thread_state
distributed.tests.test_utils ‑ test_sync
distributed.tests.test_utils ‑ test_sync_closed_loop
distributed.tests.test_utils ‑ test_sync_contextvars
distributed.tests.test_utils ‑ test_sync_error
distributed.tests.test_utils ‑ test_sync_timeout
distributed.tests.test_utils ‑ test_truncate_exception
distributed.tests.test_utils ‑ test_tuple_comparable_eq[1-1-True]
distributed.tests.test_utils ‑ test_tuple_comparable_eq[1-2-False]
distributed.tests.test_utils ‑ test_tuple_comparable_eq[None-0-True]
distributed.tests.test_utils ‑ test_tuple_comparable_eq[None-obj25-False]
distributed.tests.test_utils ‑ test_tuple_comparable_eq[obj10-obj20-True]
distributed.tests.test_utils ‑ test_tuple_comparable_eq[obj11-obj21-False]
distributed.tests.test_utils ‑ test_tuple_comparable_error
distributed.tests.test_utils ‑ test_tuple_comparable_lt[1-1-False]
distributed.tests.test_utils ‑ test_tuple_comparable_lt[1-2-True]
distributed.tests.test_utils ‑ test_tuple_comparable_lt[None-0-False]
distributed.tests.test_utils ‑ test_tuple_comparable_lt[None-obj25-True]
distributed.tests.test_utils ‑ test_tuple_comparable_lt[obj10-obj20-False]
distributed.tests.test_utils ‑ test_tuple_comparable_lt[obj11-obj21-True]
distributed.tests.test_utils ‑ test_two_loop_runners
distributed.tests.test_utils ‑ test_warn_on_duration
distributed.tests.test_utils_comm ‑ test_gather_from_workers_busy
distributed.tests.test_utils_comm ‑ test_gather_from_workers_missing_replicas
distributed.tests.test_utils_comm ‑ test_gather_from_workers_permissive
distributed.tests.test_utils_comm ‑ test_gather_from_workers_permissive_flaky
distributed.tests.test_utils_comm ‑ test_gather_from_workers_serialization_error[pickle]
distributed.tests.test_utils_comm ‑ test_gather_from_workers_serialization_error[unpickle]
distributed.tests.test_utils_comm ‑ test_pack_data
distributed.tests.test_utils_comm ‑ test_retry0_raises_immediately
distributed.tests.test_utils_comm ‑ test_retry_does_retry_and_sleep
distributed.tests.test_utils_comm ‑ test_retry_no_exception
distributed.tests.test_utils_comm ‑ test_subs_multiple
distributed.tests.test_utils_comm ‑ test_unpack_remotedata
distributed.tests.test_utils_test ‑ test__UnhashableCallable
distributed.tests.test_utils_test ‑ test_assert_story
distributed.tests.test_utils_test ‑ test_assert_story_identity[False]
distributed.tests.test_utils_test ‑ test_assert_story_identity[True]
distributed.tests.test_utils_test ‑ test_assert_story_malformed_story[Missing (stimulus_id, ts)]
distributed.tests.test_utils_test ‑ test_assert_story_malformed_story[Missing payload, stimulus_id, ts]
distributed.tests.test_utils_test ‑ test_assert_story_malformed_story[Missing ts]
distributed.tests.test_utils_test ‑ test_assert_story_malformed_story[no payload]
distributed.tests.test_utils_test ‑ test_assert_story_malformed_story[stimulus_id is an empty str]
distributed.tests.test_utils_test ‑ test_assert_story_malformed_story[stimulus_id is not a str]
distributed.tests.test_utils_test ‑ test_assert_story_malformed_story[timestamps out of order]
distributed.tests.test_utils_test ‑ test_assert_story_malformed_story[ts is in the future]
distributed.tests.test_utils_test ‑ test_assert_story_malformed_story[ts is not a float]
distributed.tests.test_utils_test ‑ test_assert_story_malformed_story[ts is too old]
distributed.tests.test_utils_test ‑ test_bare_cluster
distributed.tests.test_utils_test ‑ test_captured_context_meter
distributed.tests.test_utils_test ‑ test_captured_logger
distributed.tests.test_utils_test ‑ test_check_process_leak
distributed.tests.test_utils_test ‑ test_check_process_leak_post_cleanup[False]
distributed.tests.test_utils_test ‑ test_check_process_leak_post_cleanup[True]
distributed.tests.test_utils_test ‑ test_check_process_leak_pre_cleanup[False]
distributed.tests.test_utils_test ‑ test_check_process_leak_pre_cleanup[True]
distributed.tests.test_utils_test ‑ test_check_process_leak_slow_cleanup
distributed.tests.test_utils_test ‑ test_check_thread_leak
distributed.tests.test_utils_test ‑ test_cluster
distributed.tests.test_utils_test ‑ test_cluster_uses_config_for_test[False]
distributed.tests.test_utils_test ‑ test_cluster_uses_config_for_test[True]
distributed.tests.test_utils_test ‑ test_ensure_no_new_clients
distributed.tests.test_utils_test ‑ test_fail_hard[False]
distributed.tests.test_utils_test ‑ test_fail_hard[True]
distributed.tests.test_utils_test ‑ test_freeze_batched_send
distributed.tests.test_utils_test ‑ test_gen_cluster
distributed.tests.test_utils_test ‑ test_gen_cluster_cleans_up_client
distributed.tests.test_utils_test ‑ test_gen_cluster_multi_parametrized[a-True]
distributed.tests.test_utils_test ‑ test_gen_cluster_multi_parametrized[b-True]
distributed.tests.test_utils_test ‑ test_gen_cluster_parametrized[True]
distributed.tests.test_utils_test ‑ test_gen_cluster_parametrized_variadic_workers[True]
distributed.tests.test_utils_test ‑ test_gen_cluster_pytest_fixture
distributed.tests.test_utils_test ‑ test_gen_cluster_set_config_nanny
distributed.tests.test_utils_test ‑ test_gen_cluster_tls
distributed.tests.test_utils_test ‑ test_gen_cluster_validate
distributed.tests.test_utils_test ‑ test_gen_cluster_validate_override
distributed.tests.test_utils_test ‑ test_gen_cluster_without_client
distributed.tests.test_utils_test ‑ test_gen_test
distributed.tests.test_utils_test ‑ test_gen_test_config
distributed.tests.test_utils_test ‑ test_gen_test_config_default
distributed.tests.test_utils_test ‑ test_gen_test_double_parametrized[False-True]
distributed.tests.test_utils_test ‑ test_gen_test_legacy_explicit
distributed.tests.test_utils_test ‑ test_gen_test_legacy_implicit
distributed.tests.test_utils_test ‑ test_gen_test_parametrized[True]
distributed.tests.test_utils_test ‑ test_gen_test_pytest_fixture
distributed.tests.test_utils_test ‑ test_invalid_transitions
distributed.tests.test_utils_test ‑ test_invalid_worker_state
distributed.tests.test_utils_test ‑ test_lingering_client
distributed.tests.test_utils_test ‑ test_lingering_client_2
distributed.tests.test_utils_test ‑ test_locked_comm_drop_in_replacement
distributed.tests.test_utils_test ‑ test_locked_comm_intercept_read
distributed.tests.test_utils_test ‑ test_locked_comm_intercept_write
distributed.tests.test_utils_test ‑ test_new_config
distributed.tests.test_utils_test ‑ test_popen_always_prints_output
distributed.tests.test_utils_test ‑ test_popen_timeout
distributed.tests.test_utils_test ‑ test_popen_write_during_terminate_deadlock
distributed.tests.test_utils_test ‑ test_raises_with_cause
distributed.tests.test_utils_test ‑ test_sizeof
distributed.tests.test_utils_test ‑ test_sizeof_error[-1-ValueError-larger than]
distributed.tests.test_utils_test ‑ test_sizeof_error[0-ValueError-larger than]
distributed.tests.test_utils_test ‑ test_sizeof_error[10-ValueError-larger than]
distributed.tests.test_utils_test ‑ test_sizeof_error[12345.0-TypeError-Expected integer]
distributed.tests.test_utils_test ‑ test_start_failure_scheduler
distributed.tests.test_utils_test ‑ test_start_failure_worker[False]
distributed.tests.test_utils_test ‑ test_start_failure_worker[True]
distributed.tests.test_utils_test ‑ test_tls_cluster
distributed.tests.test_utils_test ‑ test_tls_scheduler
distributed.tests.test_utils_test ‑ test_wait_for_state
distributed.tests.test_utils_test ‑ test_wait_for_stimulus
distributed.tests.test_utils_test ‑ test_ws_with_running_task[executing]
distributed.tests.test_utils_test ‑ test_ws_with_running_task[long-running]
distributed.tests.test_variable ‑ test_Future_knows_status_immediately
distributed.tests.test_variable ‑ test_cleanup
distributed.tests.test_variable ‑ test_delete_unset_variable
distributed.tests.test_variable ‑ test_erred_future
distributed.tests.test_variable ‑ test_future_erred_sync
distributed.tests.test_variable ‑ test_hold_futures
distributed.tests.test_variable ‑ test_pickleable
distributed.tests.test_variable ‑ test_queue_with_data
distributed.tests.test_variable ‑ test_race
distributed.tests.test_variable ‑ test_set_cancelled_future
distributed.tests.test_variable ‑ test_sync
distributed.tests.test_variable ‑ test_timeout
distributed.tests.test_variable ‑ test_timeout_get
distributed.tests.test_variable ‑ test_timeout_sync
distributed.tests.test_variable ‑ test_unpickle_without_client
distributed.tests.test_variable ‑ test_variable
distributed.tests.test_variable ‑ test_variable_in_task
distributed.tests.test_variable ‑ test_variables_do_not_leak_client
distributed.tests.test_versions ‑ test_python_mismatch[scheduler]
distributed.tests.test_versions ‑ test_python_mismatch[source]
distributed.tests.test_versions ‑ test_python_mismatch[worker-1]
distributed.tests.test_versions ‑ test_python_version
distributed.tests.test_versions ‑ test_scheduler_additional_irrelevant_package
distributed.tests.test_versions ‑ test_scheduler_mismatched_irrelevant_package
distributed.tests.test_versions ‑ test_version_custom_pkgs
distributed.tests.test_versions ‑ test_version_mismatch[scheduler-KEY_ERROR]
distributed.tests.test_versions ‑ test_version_mismatch[scheduler-MISMATCHED]
distributed.tests.test_versions ‑ test_version_mismatch[scheduler-MISSING]
distributed.tests.test_versions ‑ test_version_mismatch[scheduler-NONE]
distributed.tests.test_versions ‑ test_version_mismatch[source-KEY_ERROR]
distributed.tests.test_versions ‑ test_version_mismatch[source-MISMATCHED]
distributed.tests.test_versions ‑ test_version_mismatch[source-MISSING]
distributed.tests.test_versions ‑ test_version_mismatch[source-NONE]
distributed.tests.test_versions ‑ test_version_mismatch[worker-1-KEY_ERROR]
distributed.tests.test_versions ‑ test_version_mismatch[worker-1-MISMATCHED]
distributed.tests.test_versions ‑ test_version_mismatch[worker-1-MISSING]
distributed.tests.test_versions ‑ test_version_mismatch[worker-1-NONE]
distributed.tests.test_versions ‑ test_version_warning_in_cluster
distributed.tests.test_versions ‑ test_versions_match
distributed.tests.test_worker ‑ test_Executor
distributed.tests.test_worker ‑ test_Worker__to_dict
distributed.tests.test_worker ‑ test_access_key
distributed.tests.test_worker ‑ test_acquire_replicas
distributed.tests.test_worker ‑ test_acquire_replicas_already_in_flight
distributed.tests.test_worker ‑ test_acquire_replicas_large_data
distributed.tests.test_worker ‑ test_acquire_replicas_many
distributed.tests.test_worker ‑ test_acquire_replicas_same_channel
distributed.tests.test_worker ‑ test_acquire_replicas_with_no_priority
distributed.tests.test_worker ‑ test_avoid_oversubscription
distributed.tests.test_worker ‑ test_bad_executor_annotation
distributed.tests.test_worker ‑ test_bad_local_directory
distributed.tests.test_worker ‑ test_bad_metrics
distributed.tests.test_worker ‑ test_bad_startup
distributed.tests.test_worker ‑ test_base_exception_in_task[BaseException-False]
distributed.tests.test_worker ‑ test_base_exception_in_task[BaseException-True]
distributed.tests.test_worker ‑ test_base_exception_in_task[CancelledError-False]
distributed.tests.test_worker ‑ test_base_exception_in_task[CancelledError-True]
distributed.tests.test_worker ‑ test_base_exception_in_task[KeyboardInterrupt-False]
distributed.tests.test_worker ‑ test_base_exception_in_task[KeyboardInterrupt-True]
distributed.tests.test_worker ‑ test_base_exception_in_task[SystemExit-False]
distributed.tests.test_worker ‑ test_base_exception_in_task[SystemExit-True]
distributed.tests.test_worker ‑ test_benchmark_hardware
distributed.tests.test_worker ‑ test_broadcast
distributed.tests.test_worker ‑ test_broken_comm
distributed.tests.test_worker ‑ test_chained_error_message
distributed.tests.test_worker ‑ test_clean
distributed.tests.test_worker ‑ test_clean_nbytes
distributed.tests.test_worker ‑ test_clean_up_dependencies
distributed.tests.test_worker ‑ test_close_async_task_handles_cancellation
distributed.tests.test_worker ‑ test_close_gracefully
distributed.tests.test_worker ‑ test_close_gracefully_no_suspicious_tasks
distributed.tests.test_worker ‑ test_close_on_disconnect
distributed.tests.test_worker ‑ test_close_while_executing[False]
distributed.tests.test_worker ‑ test_close_while_executing[True]
distributed.tests.test_worker ‑ test_custom_metrics
distributed.tests.test_worker ‑ test_dataframe_attribute_error
distributed.tests.test_worker ‑ test_default_worker_dir
distributed.tests.test_worker ‑ test_deprecation_of_renamed_worker_attributes
distributed.tests.test_worker ‑ test_deque_handler
distributed.tests.test_worker ‑ test_do_not_block_event_loop_during_shutdown
distributed.tests.test_worker ‑ test_dont_overlap_communications_to_same_worker
distributed.tests.test_worker ‑ test_error_message
distributed.tests.test_worker ‑ test_execute_preamble_abort_retirement
distributed.tests.test_worker ‑ test_executor_offload
distributed.tests.test_worker ‑ test_extension_methods
distributed.tests.test_worker ‑ test_forget_acquire_replicas
distributed.tests.test_worker ‑ test_forget_dependents_after_release
distributed.tests.test_worker ‑ test_forward_output
distributed.tests.test_worker ‑ test_gather
distributed.tests.test_worker ‑ test_gather_dep_cancelled_rescheduled
distributed.tests.test_worker ‑ test_gather_dep_do_not_handle_response_of_not_requested_tasks
distributed.tests.test_worker ‑ test_gather_dep_from_remote_workers_if_all_local_workers_are_busy
distributed.tests.test_worker ‑ test_gather_dep_local_workers_first
distributed.tests.test_worker ‑ test_gather_dep_no_longer_in_flight_tasks
distributed.tests.test_worker ‑ test_gather_dep_one_worker_always_busy
distributed.tests.test_worker ‑ test_gather_many_small[False]
distributed.tests.test_worker ‑ test_gather_many_small[True]
distributed.tests.test_worker ‑ test_gather_missing_keys
distributed.tests.test_worker ‑ test_gather_missing_workers
distributed.tests.test_worker ‑ test_gather_missing_workers_replicated[False]
distributed.tests.test_worker ‑ test_gather_missing_workers_replicated[True0]
distributed.tests.test_worker ‑ test_gather_missing_workers_replicated[True1]
distributed.tests.test_worker ‑ test_gather_missing_workers_replicated[True2]
distributed.tests.test_worker ‑ test_gather_missing_workers_replicated[True3]
distributed.tests.test_worker ‑ test_get_client
distributed.tests.test_worker ‑ test_get_client_coroutine
distributed.tests.test_worker ‑ test_get_client_coroutine_sync
distributed.tests.test_worker ‑ test_get_client_sync
distributed.tests.test_worker ‑ test_get_current_task
distributed.tests.test_worker ‑ test_get_data_cancelled_error
distributed.tests.test_worker ‑ test_global_workers
distributed.tests.test_worker ‑ test_heartbeat_comm_closed
distributed.tests.test_worker ‑ test_heartbeat_missing
distributed.tests.test_worker ‑ test_heartbeat_missing_doesnt_restart
distributed.tests.test_worker ‑ test_heartbeat_missing_real_cluster
distributed.tests.test_worker ‑ test_heartbeats
distributed.tests.test_worker ‑ test_hold_on_to_replicas
distributed.tests.test_worker ‑ test_hold_onto_dependents
distributed.tests.test_worker ‑ test_host_address
distributed.tests.test_worker ‑ test_host_uses_scheduler_protocol
distributed.tests.test_worker ‑ test_identity
distributed.tests.test_worker ‑ test_inter_worker_communication
distributed.tests.test_worker ‑ test_interface_async[Nanny]
distributed.tests.test_worker ‑ test_interface_async[Worker]
distributed.tests.test_worker ‑ test_io_loop
distributed.tests.test_worker ‑ test_io_loop_alternate_loop
distributed.tests.test_worker ‑ test_lifetime
distributed.tests.test_worker ‑ test_lifetime_stagger
distributed.tests.test_worker ‑ test_local_directory
distributed.tests.test_worker ‑ test_local_directory_make_new_directory
distributed.tests.test_worker ‑ test_log_exception_on_failed_task
distributed.tests.test_worker ‑ test_log_remove_worker
distributed.tests.test_worker ‑ test_memory_limit_auto
distributed.tests.test_worker ‑ test_message_breakup
distributed.tests.test_worker ‑ test_missing_released_zombie_tasks
distributed.tests.test_worker ‑ test_missing_released_zombie_tasks_2
distributed.tests.test_worker ‑ test_multiple_executors
distributed.tests.test_worker ‑ test_multiple_transfers
distributed.tests.test_worker ‑ test_offload_getdata
distributed.tests.test_worker ‑ test_pid
distributed.tests.test_worker ‑ test_plugin_exception
distributed.tests.test_worker ‑ test_plugin_internal_exception
distributed.tests.test_worker ‑ test_plugin_multiple_exceptions
distributed.tests.test_worker ‑ test_prefer_gather_from_local_address
distributed.tests.test_worker ‑ test_priorities
distributed.tests.test_worker ‑ test_process_executor
distributed.tests.test_worker ‑ test_process_executor_kills_process
distributed.tests.test_worker ‑ test_process_executor_raise_exception
distributed.tests.test_worker ‑ test_protocol_from_scheduler_address[Nanny]
distributed.tests.test_worker ‑ test_protocol_from_scheduler_address[Worker]
distributed.tests.test_worker ‑ test_reconnect_argument_deprecated
distributed.tests.test_worker ‑ test_register_worker_callbacks
distributed.tests.test_worker ‑ test_register_worker_callbacks_err
distributed.tests.test_worker ‑ test_remove_replicas_simple
distributed.tests.test_worker ‑ test_restrictions
distributed.tests.test_worker ‑ test_run_coroutine_dask_worker
distributed.tests.test_worker ‑ test_run_dask_worker
distributed.tests.test_worker ‑ test_run_dask_worker_kwonlyarg
distributed.tests.test_worker ‑ test_scheduler_address_config
distributed.tests.test_worker ‑ test_scheduler_delay
distributed.tests.test_worker ‑ test_scheduler_file
distributed.tests.test_worker ‑ test_service_hosts_match_worker
distributed.tests.test_worker ‑ test_share_communication
distributed.tests.test_worker ‑ test_shutdown_on_scheduler_comm_closed
distributed.tests.test_worker ‑ test_start_services
distributed.tests.test_worker ‑ test_startstops
distributed.tests.test_worker ‑ test_statistical_profiling
distributed.tests.test_worker ‑ test_statistical_profiling_2
distributed.tests.test_worker ‑ test_statistical_profiling_cycle
distributed.tests.test_worker ‑ test_stimulus_story
distributed.tests.test_worker ‑ test_stop_doing_unnecessary_work
distributed.tests.test_worker ‑ test_story
distributed.tests.test_worker ‑ test_str
distributed.tests.test_worker ‑ test_suppress_compute_failure_for_cancelled_tasks
distributed.tests.test_worker ‑ test_suppress_keyerror_for_cancelled_tasks[cancelled]
distributed.tests.test_worker ‑ test_suppress_keyerror_for_cancelled_tasks[resumed]
distributed.tests.test_worker ‑ test_system_monitor
distributed.tests.test_worker ‑ test_task_flight_compute_oserror
distributed.tests.test_worker ‑ test_taskstate_metadata
distributed.tests.test_worker ‑ test_tick_interval
distributed.tests.test_worker ‑ test_types
distributed.tests.test_worker ‑ test_update_latency
distributed.tests.test_worker ‑ test_upload_egg
distributed.tests.test_worker ‑ test_upload_file
distributed.tests.test_worker ‑ test_upload_file_pyc
distributed.tests.test_worker ‑ test_upload_large_file
distributed.tests.test_worker ‑ test_upload_pyz
distributed.tests.test_worker ‑ test_wait_for_outgoing
distributed.tests.test_worker ‑ test_who_has_consistent_remove_replicas
distributed.tests.test_worker ‑ test_worker_bad_args
distributed.tests.test_worker ‑ test_worker_client_closes_if_created_on_worker_last_worker_alive
distributed.tests.test_worker ‑ test_worker_client_closes_if_created_on_worker_one_worker
distributed.tests.test_worker ‑ test_worker_client_uses_default_no_close
distributed.tests.test_worker ‑ test_worker_death_timeout
distributed.tests.test_worker ‑ test_worker_descopes_data
distributed.tests.test_worker ‑ test_worker_dir[Nanny]
distributed.tests.test_worker ‑ test_worker_dir[Worker]
distributed.tests.test_worker ‑ test_worker_fds
distributed.tests.test_worker ‑ test_worker_listens_on_same_interface_by_default[Nanny]
distributed.tests.test_worker ‑ test_worker_listens_on_same_interface_by_default[Worker]
distributed.tests.test_worker ‑ test_worker_nthreads
distributed.tests.test_worker ‑ test_worker_port_range
distributed.tests.test_worker ‑ test_worker_running_before_running_plugins
distributed.tests.test_worker ‑ test_worker_state_error_long_chain
distributed.tests.test_worker ‑ test_worker_state_error_release_error_first
distributed.tests.test_worker ‑ test_worker_state_error_release_error_int
distributed.tests.test_worker ‑ test_worker_state_error_release_error_last
distributed.tests.test_worker ‑ test_worker_status_sync
distributed.tests.test_worker ‑ test_worker_task_data
distributed.tests.test_worker ‑ test_worker_waits_for_scheduler
distributed.tests.test_worker ‑ test_worker_with_port_zero
distributed.tests.test_worker ‑ test_workerstate_executing
distributed.tests.test_worker_client ‑ test_async
distributed.tests.test_worker_client ‑ test_client_executor
distributed.tests.test_worker_client ‑ test_closing_worker_doesnt_close_client
distributed.tests.test_worker_client ‑ test_compute_within_worker_client
distributed.tests.test_worker_client ‑ test_dont_override_default_get
distributed.tests.test_worker_client ‑ test_gather_multi_machine
distributed.tests.test_worker_client ‑ test_local_client_warning
distributed.tests.test_worker_client ‑ test_log_event
distributed.tests.test_worker_client ‑ test_log_event_implicit
distributed.tests.test_worker_client ‑ test_same_loop
distributed.tests.test_worker_client ‑ test_scatter_from_worker
distributed.tests.test_worker_client ‑ test_scatter_singleton
distributed.tests.test_worker_client ‑ test_secede_does_not_claim_worker
distributed.tests.test_worker_client ‑ test_secede_without_stealing_issue_1262
distributed.tests.test_worker_client ‑ test_separate_thread_false
distributed.tests.test_worker_client ‑ test_submit_different_names
distributed.tests.test_worker_client ‑ test_submit_from_worker
distributed.tests.test_worker_client ‑ test_submit_from_worker_async
distributed.tests.test_worker_client ‑ test_sync
distributed.tests.test_worker_client ‑ test_timeout
distributed.tests.test_worker_client ‑ test_worker_client_rejoins
distributed.tests.test_worker_memory ‑ test_avoid_memory_monitor_if_zero_limit_nanny
distributed.tests.test_worker_memory ‑ test_avoid_memory_monitor_if_zero_limit_worker
distributed.tests.test_worker_memory ‑ test_delete_spilled_keys
distributed.tests.test_worker_memory ‑ test_deprecated_attributes[Nanny-memory_limit-123000000000.0]
distributed.tests.test_worker_memory ‑ test_deprecated_attributes[Nanny-memory_terminate_fraction-0.789]
distributed.tests.test_worker_memory ‑ test_deprecated_attributes[Worker-memory_limit-123000000000.0]
distributed.tests.test_worker_memory ‑ test_deprecated_attributes[Worker-memory_pause_fraction-0.789]
distributed.tests.test_worker_memory ‑ test_deprecated_attributes[Worker-memory_spill_fraction-0.789]
distributed.tests.test_worker_memory ‑ test_deprecated_attributes[Worker-memory_target_fraction-0.789]
distributed.tests.test_worker_memory ‑ test_deprecated_memory_monitor_method_nanny
distributed.tests.test_worker_memory ‑ test_deprecated_memory_monitor_method_worker
distributed.tests.test_worker_memory ‑ test_deprecated_params[memory_pause_fraction]
distributed.tests.test_worker_memory ‑ test_deprecated_params[memory_spill_fraction]
distributed.tests.test_worker_memory ‑ test_deprecated_params[memory_target_fraction]
distributed.tests.test_worker_memory ‑ test_dict_data_if_no_spill_to_disk
distributed.tests.test_worker_memory ‑ test_disk_cleanup_on_terminate[False]
distributed.tests.test_worker_memory ‑ test_disk_cleanup_on_terminate[True]
distributed.tests.test_worker_memory ‑ test_fail_to_pickle_execute_1
distributed.tests.test_worker_memory ‑ test_fail_to_pickle_execute_2
distributed.tests.test_worker_memory ‑ test_fail_to_pickle_spill
distributed.tests.test_worker_memory ‑ test_high_unmanaged_memory_warning
distributed.tests.test_worker_memory ‑ test_manual_evict_proto
distributed.tests.test_worker_memory ‑ test_nanny_terminate
distributed.tests.test_worker_memory ‑ test_override_data_nanny
distributed.tests.test_worker_memory ‑ test_override_data_vs_memory_monitor
distributed.tests.test_worker_memory ‑ test_override_data_worker
distributed.tests.test_worker_memory ‑ test_parse_memory_limit_nanny
distributed.tests.test_worker_memory ‑ test_parse_memory_limit_worker
distributed.tests.test_worker_memory ‑ test_parse_memory_limit_worker_relative
distributed.tests.test_worker_memory ‑ test_parse_memory_limit_zero
distributed.tests.test_worker_memory ‑ test_pause_executor_manual
distributed.tests.test_worker_memory ‑ test_pause_executor_with_memory_monitor
distributed.tests.test_worker_memory ‑ test_pause_prevents_deps_fetch
distributed.tests.test_worker_memory ‑ test_pause_while_idle
distributed.tests.test_worker_memory ‑ test_pause_while_saturated
distributed.tests.test_worker_memory ‑ test_pause_while_spilling
distributed.tests.test_worker_memory ‑ test_release_evloop_while_spilling
distributed.tests.test_worker_memory ‑ test_resource_limit
distributed.tests.test_worker_memory ‑ test_spill_constrained
distributed.tests.test_worker_memory ‑ test_spill_hysteresis[0.4-0-7]
distributed.tests.test_worker_memory ‑ test_spill_hysteresis[0.7-0-1]
distributed.tests.test_worker_memory ‑ test_spill_hysteresis[False-10000000000-1]
distributed.tests.test_worker_memory ‑ test_spill_spill_threshold
distributed.tests.test_worker_memory ‑ test_spill_target_threshold
distributed.tests.test_worker_memory ‑ test_worker_data_callable_kwargs
distributed.tests.test_worker_memory ‑ test_worker_data_callable_local_directory
distributed.tests.test_worker_memory ‑ test_worker_data_callable_local_directory_kwargs
distributed.tests.test_worker_memory ‑ test_worker_log_memory_limit_too_high
distributed.tests.test_worker_memory ‑ test_workerstate_fail_to_pickle_execute_1[executing]
distributed.tests.test_worker_memory ‑ test_workerstate_fail_to_pickle_execute_1[long-running]
distributed.tests.test_worker_memory ‑ test_workerstate_fail_to_pickle_flight
distributed.tests.test_worker_metrics ‑ test_async_task
distributed.tests.test_worker_metrics ‑ test_cancelled_execute
distributed.tests.test_worker_metrics ‑ test_cancelled_flight
distributed.tests.test_worker_metrics ‑ test_custom_executor
distributed.tests.test_worker_metrics ‑ test_delayed_ledger_is_not_reentrant
distributed.tests.test_worker_metrics ‑ test_do_not_leak_metrics
distributed.tests.test_worker_metrics ‑ test_execute_failed
distributed.tests.test_worker_metrics ‑ test_gather_dep_busy
distributed.tests.test_worker_metrics ‑ test_gather_dep_failed
distributed.tests.test_worker_metrics ‑ test_gather_dep_network_error
distributed.tests.test_worker_metrics ‑ test_gather_dep_no_task
distributed.tests.test_worker_metrics ‑ test_int_metrics
distributed.tests.test_worker_metrics ‑ test_memory_monitor
distributed.tests.test_worker_metrics ‑ test_new_metrics_during_heartbeat
distributed.tests.test_worker_metrics ‑ test_no_spans_extension
distributed.tests.test_worker_metrics ‑ test_offload
distributed.tests.test_worker_metrics ‑ test_reschedule
distributed.tests.test_worker_metrics ‑ test_send_metrics_to_scheduler
distributed.tests.test_worker_metrics ‑ test_task_lifecycle
distributed.tests.test_worker_metrics ‑ test_user_metrics_async
distributed.tests.test_worker_metrics ‑ test_user_metrics_fail
distributed.tests.test_worker_metrics ‑ test_user_metrics_sync
distributed.tests.test_worker_metrics ‑ test_user_metrics_weird
distributed.tests.test_worker_state_machine ‑ test_TaskState__to_dict
distributed.tests.test_worker_state_machine ‑ test_TaskState_eq
distributed.tests.test_worker_state_machine ‑ test_TaskState_get_nbytes
distributed.tests.test_worker_state_machine ‑ test_TaskState_repr
distributed.tests.test_worker_state_machine ‑ test_TaskState_tracking
distributed.tests.test_worker_state_machine ‑ test_WorkerState__to_dict
distributed.tests.test_worker_state_machine ‑ test_WorkerState_pickle
distributed.tests.test_worker_state_machine ‑ test_aggregate_gather_deps[10000000-3-1]
distributed.tests.test_worker_state_machine ‑ test_aggregate_gather_deps[10000000-3-2]
distributed.tests.test_worker_state_machine ‑ test_aggregate_gather_deps[20000000-2-1]
distributed.tests.test_worker_state_machine ‑ test_aggregate_gather_deps[20000000-2-2]
distributed.tests.test_worker_state_machine ‑ test_aggregate_gather_deps[30000000-1-1]
distributed.tests.test_worker_state_machine ‑ test_aggregate_gather_deps[30000000-1-2]
distributed.tests.test_worker_state_machine ‑ test_aggregate_gather_deps[60000000-1-1]
distributed.tests.test_worker_state_machine ‑ test_aggregate_gather_deps[60000000-1-2]
distributed.tests.test_worker_state_machine ‑ test_cancelled_while_in_flight
distributed.tests.test_worker_state_machine ‑ test_clean_log
distributed.tests.test_worker_state_machine ‑ test_computetask_dummy
distributed.tests.test_worker_state_machine ‑ test_computetask_to_dict
distributed.tests.test_worker_state_machine ‑ test_deprecated_worker_attributes
distributed.tests.test_worker_state_machine ‑ test_do_not_throttle_connections_while_below_threshold
distributed.tests.test_worker_state_machine ‑ test_done_resumed_task_not_in_all_running_tasks[executing-ExecuteFailureEvent]
distributed.tests.test_worker_state_machine ‑ test_done_resumed_task_not_in_all_running_tasks[executing-ExecuteSuccessEvent]
distributed.tests.test_worker_state_machine ‑ test_done_resumed_task_not_in_all_running_tasks[executing-RescheduleEvent]
distributed.tests.test_worker_state_machine ‑ test_done_resumed_task_not_in_all_running_tasks[long-running-ExecuteFailureEvent]
distributed.tests.test_worker_state_machine ‑ test_done_resumed_task_not_in_all_running_tasks[long-running-ExecuteSuccessEvent]
distributed.tests.test_worker_state_machine ‑ test_done_resumed_task_not_in_all_running_tasks[long-running-RescheduleEvent]
distributed.tests.test_worker_state_machine ‑ test_done_task_not_in_all_running_tasks[executing-ExecuteFailureEvent]
distributed.tests.test_worker_state_machine ‑ test_done_task_not_in_all_running_tasks[executing-ExecuteSuccessEvent]
distributed.tests.test_worker_state_machine ‑ test_done_task_not_in_all_running_tasks[executing-RescheduleEvent]
distributed.tests.test_worker_state_machine ‑ test_done_task_not_in_all_running_tasks[long-running-ExecuteFailureEvent]
distributed.tests.test_worker_state_machine ‑ test_done_task_not_in_all_running_tasks[long-running-ExecuteSuccessEvent]
distributed.tests.test_worker_state_machine ‑ test_done_task_not_in_all_running_tasks[long-running-RescheduleEvent]
distributed.tests.test_worker_state_machine ‑ test_event_to_dict_with_annotations
distributed.tests.test_worker_state_machine ‑ test_event_to_dict_without_annotations
distributed.tests.test_worker_state_machine ‑ test_executefailure_dummy
distributed.tests.test_worker_state_machine ‑ test_executefailure_to_dict
distributed.tests.test_worker_state_machine ‑ test_executesuccess_dummy
distributed.tests.test_worker_state_machine ‑ test_executesuccess_to_dict
distributed.tests.test_worker_state_machine ‑ test_fetch_count
distributed.tests.test_worker_state_machine ‑ test_fetch_to_compute
distributed.tests.test_worker_state_machine ‑ test_fetch_to_missing_on_busy
distributed.tests.test_worker_state_machine ‑ test_fetch_to_missing_on_network_failure
distributed.tests.test_worker_state_machine ‑ test_fetch_to_missing_on_refresh_who_has
distributed.tests.test_worker_state_machine ‑ test_fetch_via_amm_to_compute
distributed.tests.test_worker_state_machine ‑ test_forget_data_needed
distributed.tests.test_worker_state_machine ‑ test_gather_dep_failure
distributed.tests.test_worker_state_machine ‑ test_gather_priority
distributed.tests.test_worker_state_machine ‑ test_in_memory_while_in_flight
distributed.tests.test_worker_state_machine ‑ test_instruction_match
distributed.tests.test_worker_state_machine ‑ test_lose_replica_during_fetch[False]
distributed.tests.test_worker_state_machine ‑ test_lose_replica_during_fetch[True]
distributed.tests.test_worker_state_machine ‑ test_merge_recs_instructions
distributed.tests.test_worker_state_machine ‑ test_message_target_does_not_affect_first_transfer_on_different_worker
distributed.tests.test_worker_state_machine ‑ test_missing_handle_compute_dependency
distributed.tests.test_worker_state_machine ‑ test_missing_to_waiting
distributed.tests.test_worker_state_machine ‑ test_new_replica_while_all_workers_in_flight
distributed.tests.test_worker_state_machine ‑ test_pickle_exceptions[False-InvalidTaskState-kwargs2]
distributed.tests.test_worker_state_machine ‑ test_pickle_exceptions[False-InvalidTransition-kwargs0]
distributed.tests.test_worker_state_machine ‑ test_pickle_exceptions[False-TransitionCounterMaxExceeded-kwargs1]
distributed.tests.test_worker_state_machine ‑ test_pickle_exceptions[True-InvalidTaskState-kwargs2]
distributed.tests.test_worker_state_machine ‑ test_pickle_exceptions[True-InvalidTransition-kwargs0]
distributed.tests.test_worker_state_machine ‑ test_pickle_exceptions[True-TransitionCounterMaxExceeded-kwargs1]
distributed.tests.test_worker_state_machine ‑ test_recompute_erred_task
distributed.tests.test_worker_state_machine ‑ test_remove_worker_unknown
distributed.tests.test_worker_state_machine ‑ test_remove_worker_while_in_fetch
distributed.tests.test_worker_state_machine ‑ test_remove_worker_while_in_flight[busy]
distributed.tests.test_worker_state_machine ‑ test_remove_worker_while_in_flight[fail]
distributed.tests.test_worker_state_machine ‑ test_remove_worker_while_in_flight[no-key]
distributed.tests.test_worker_state_machine ‑ test_remove_worker_while_in_flight[success]
distributed.tests.test_worker_state_machine ‑ test_remove_worker_while_in_flight_unused_peer
distributed.tests.test_worker_state_machine ‑ test_resumed_task_releases_resources[executing-ExecuteFailureEvent]
distributed.tests.test_worker_state_machine ‑ test_resumed_task_releases_resources[executing-ExecuteSuccessEvent]
distributed.tests.test_worker_state_machine ‑ test_resumed_task_releases_resources[executing-RescheduleEvent]
distributed.tests.test_worker_state_machine ‑ test_resumed_task_releases_resources[long-running-ExecuteFailureEvent]
distributed.tests.test_worker_state_machine ‑ test_resumed_task_releases_resources[long-running-ExecuteSuccessEvent]
distributed.tests.test_worker_state_machine ‑ test_resumed_task_releases_resources[long-running-RescheduleEvent]
distributed.tests.test_worker_state_machine ‑ test_running_task_in_all_running_tasks[executing]
distributed.tests.test_worker_state_machine ‑ test_running_task_in_all_running_tasks[long-running]
distributed.tests.test_worker_state_machine ‑ test_sendmsg_to_dict
distributed.tests.test_worker_state_machine ‑ test_slots[AcquireReplicasEvent]
distributed.tests.test_worker_state_machine ‑ test_slots[AddKeysMsg]
distributed.tests.test_worker_state_machine ‑ test_slots[CancelComputeEvent]
distributed.tests.test_worker_state_machine ‑ test_slots[ComputeTaskEvent]
distributed.tests.test_worker_state_machine ‑ test_slots[ExecuteDoneEvent]
distributed.tests.test_worker_state_machine ‑ test_slots[ExecuteFailureEvent]
distributed.tests.test_worker_state_machine ‑ test_slots[ExecuteSuccessEvent]
distributed.tests.test_worker_state_machine ‑ test_slots[Execute]
distributed.tests.test_worker_state_machine ‑ test_slots[FindMissingEvent]
distributed.tests.test_worker_state_machine ‑ test_slots[FreeKeysEvent]
distributed.tests.test_worker_state_machine ‑ test_slots[GatherDepBusyEvent]
distributed.tests.test_worker_state_machine ‑ test_slots[GatherDepDoneEvent]
distributed.tests.test_worker_state_machine ‑ test_slots[GatherDepFailureEvent]
distributed.tests.test_worker_state_machine ‑ test_slots[GatherDepNetworkFailureEvent]
distributed.tests.test_worker_state_machine ‑ test_slots[GatherDepSuccessEvent]
distributed.tests.test_worker_state_machine ‑ test_slots[GatherDep]
distributed.tests.test_worker_state_machine ‑ test_slots[Instruction]
distributed.tests.test_worker_state_machine ‑ test_slots[LongRunningMsg]
distributed.tests.test_worker_state_machine ‑ test_slots[PauseEvent]
distributed.tests.test_worker_state_machine ‑ test_slots[RefreshWhoHasEvent]
distributed.tests.test_worker_state_machine ‑ test_slots[ReleaseWorkerDataMsg]
distributed.tests.test_worker_state_machine ‑ test_slots[RemoveReplicasEvent]
distributed.tests.test_worker_state_machine ‑ test_slots[RemoveWorkerEvent]
distributed.tests.test_worker_state_machine ‑ test_slots[RequestRefreshWhoHasMsg]
distributed.tests.test_worker_state_machine ‑ test_slots[RescheduleEvent]
distributed.tests.test_worker_state_machine ‑ test_slots[RescheduleMsg]
distributed.tests.test_worker_state_machine ‑ test_slots[RetryBusyWorkerEvent]
distributed.tests.test_worker_state_machine ‑ test_slots[RetryBusyWorkerLater]
distributed.tests.test_worker_state_machine ‑ test_slots[SecedeEvent]
distributed.tests.test_worker_state_machine ‑ test_slots[SendMessageToScheduler]
distributed.tests.test_worker_state_machine ‑ test_slots[StateMachineEvent]
distributed.tests.test_worker_state_machine ‑ test_slots[StealRequestEvent]
distributed.tests.test_worker_state_machine ‑ test_slots[StealResponseMsg]
distributed.tests.test_worker_state_machine ‑ test_slots[TaskErredMsg]
distributed.tests.test_worker_state_machine ‑ test_slots[TaskFinishedMsg]
distributed.tests.test_worker_state_machine ‑ test_slots[TaskState]
distributed.tests.test_worker_state_machine ‑ test_slots[UnpauseEvent]
distributed.tests.test_worker_state_machine ‑ test_slots[UpdateDataEvent]
distributed.tests.test_worker_state_machine ‑ test_task_acquires_resources[executing]
distributed.tests.test_worker_state_machine ‑ test_task_acquires_resources[long-running]
distributed.tests.test_worker_state_machine ‑ test_task_counter
distributed.tests.test_worker_state_machine ‑ test_task_releases_resources[executing-ExecuteFailureEvent]
distributed.tests.test_worker_state_machine ‑ test_task_releases_resources[executing-ExecuteSuccessEvent]
distributed.tests.test_worker_state_machine ‑ test_task_releases_resources[executing-RescheduleEvent]
distributed.tests.test_worker_state_machine ‑ test_task_releases_resources[long-running-ExecuteFailureEvent]
distributed.tests.test_worker_state_machine ‑ test_task_releases_resources[long-running-ExecuteSuccessEvent]
distributed.tests.test_worker_state_machine ‑ test_task_releases_resources[long-running-RescheduleEvent]
distributed.tests.test_worker_state_machine ‑ test_task_state_instance_are_garbage_collected
distributed.tests.test_worker_state_machine ‑ test_task_with_dependencies_acquires_resources
distributed.tests.test_worker_state_machine ‑ test_throttle_incoming_transfers_on_count_limit
distributed.tests.test_worker_state_machine ‑ test_throttle_on_transfer_bytes_regardless_of_threshold
distributed.tests.test_worker_state_machine ‑ test_throttling_does_not_affect_first_transfer
distributed.tests.test_worker_state_machine ‑ test_throttling_incoming_transfer_on_transfer_bytes_different_workers
distributed.tests.test_worker_state_machine ‑ test_throttling_incoming_transfer_on_transfer_bytes_same_worker
distributed.tests.test_worker_state_machine ‑ test_transfer_incoming_metrics
distributed.tests.test_worker_state_machine ‑ test_updatedata_to_dict
distributed.tests.test_worker_state_machine ‑ test_worker_nbytes[executing]
distributed.tests.test_worker_state_machine ‑ test_worker_nbytes[long-running]
View more details on GitHub Actions