Provide close reason when signal is caught #124
GitHub Actions / Unit Test Results
failed
Jul 28, 2023 in 0s
12 fail, 106 skipped, 3 623 pass in 10h 34m 14s
Annotations
Check warning on line 0 in distributed.tests.test_client
github-actions / Unit Test Results
1 out of 10 runs failed: test_file_descriptors_dont_leak[Nanny] (distributed.tests.test_client)
artifacts/macos-latest-3.11-queue-ci1/pytest.xml [took 22s]
Raw output
AssertionError: (27, 28)
assert 1690540676.976778 < (1690540666.975136 + 10)
+ where 1690540676.976778 = time()
Worker = <class 'distributed.nanny.Nanny'>
@pytest.mark.skipif(WINDOWS, reason="num_fds not supported on windows")
@pytest.mark.parametrize(
"Worker", [Worker, pytest.param(Nanny, marks=[pytest.mark.slow])]
)
@gen_test()
async def test_file_descriptors_dont_leak(Worker):
pytest.importorskip("pandas")
df = dask.datasets.timeseries(freq="10s", dtypes={"x": int, "y": float})
proc = psutil.Process()
before = proc.num_fds()
async with Scheduler(dashboard_address=":0") as s:
async with Worker(s.address), Worker(s.address), Client(
s.address, asynchronous=True
):
assert proc.num_fds() > before
await df.sum().persist()
start = time()
while proc.num_fds() > before:
await asyncio.sleep(0.01)
> assert time() < start + 10, (before, proc.num_fds())
E AssertionError: (27, 28)
E assert 1690540676.976778 < (1690540666.975136 + 10)
E + where 1690540676.976778 = time()
distributed/tests/test_client.py:6406: AssertionError
Check warning on line 0 in distributed.tests.test_failed_workers
github-actions / Unit Test Results
1 out of 10 runs failed: test_submit_after_failed_worker_async[True] (distributed.tests.test_failed_workers)
artifacts/ubuntu-latest-mindeps-queue-ci1/pytest.xml [took 2s]
Raw output
concurrent.futures._base.CancelledError: sum-1662e8752439e04be62efae3b3703604
c = <Client: No scheduler connected>
s = <Scheduler 'tcp://127.0.0.1:41065', workers: 0, cores: 0, tasks: 0>
a = <Worker 'tcp://127.0.0.1:45975', name: 0, status: closed, stored: 0, running: 0/1, ready: 0, comm: 0, waiting: 0>
b = <Worker 'tcp://127.0.0.1:42777', name: 1, status: closed, stored: 0, running: 0/2, ready: 0, comm: 0, waiting: 0>
compute_on_failed = True
@pytest.mark.slow()
@pytest.mark.parametrize("compute_on_failed", [False, True])
@gen_cluster(client=True, config={"distributed.comm.timeouts.connect": "500ms"})
async def test_submit_after_failed_worker_async(c, s, a, b, compute_on_failed):
async with Nanny(s.address, nthreads=2) as n:
await c.wait_for_workers(3)
L = c.map(inc, range(10))
await wait(L)
kill_task = asyncio.create_task(n.kill())
compute_addr = n.worker_address if compute_on_failed else a.address
total = c.submit(sum, L, workers=[compute_addr], allow_other_workers=True)
> assert await total == sum(range(1, 11))
distributed/tests/test_failed_workers.py:64:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
self = <Future: cancelled, key: sum-1662e8752439e04be62efae3b3703604>
raiseit = True
async def _result(self, raiseit=True):
await self._state.wait()
if self.status == "error":
exc = clean_exception(self._state.exception, self._state.traceback)
if raiseit:
typ, exc, tb = exc
raise exc.with_traceback(tb)
else:
return exc
elif self.status == "cancelled":
exception = CancelledError(self.key)
if raiseit:
> raise exception
E concurrent.futures._base.CancelledError: sum-1662e8752439e04be62efae3b3703604
distributed/client.py:345: CancelledError
Check warning on line 0 in distributed.tests.test_scheduler
github-actions / Unit Test Results
1 out of 10 runs failed: test_queued_remove_add_worker (distributed.tests.test_scheduler)
artifacts/macos-latest-3.11-queue-ci1/pytest.xml [took 0s]
Raw output
RuntimeError: ('Unclosed Comms', [<TCP (closed) ConnectionPool local=tcp://127.0.0.1:57589 remote=tcp://127.0.0.1:57580>])
args = (), kwds = {}
@wraps(func)
def inner(*args, **kwds):
with self._recreate_cm():
> return func(*args, **kwds)
../../../miniconda3/envs/dask-distributed/lib/python3.11/contextlib.py:81:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
../../../miniconda3/envs/dask-distributed/lib/python3.11/contextlib.py:81: in inner
return func(*args, **kwds)
distributed/utils_test.py:1100: in test_func
return _run_and_close_tornado(async_fn_outer)
distributed/utils_test.py:378: in _run_and_close_tornado
return asyncio_run(inner_fn(), loop_factory=get_loop_factory())
distributed/compatibility.py:204: in asyncio_run
return runner.run(main)
../../../miniconda3/envs/dask-distributed/lib/python3.11/asyncio/runners.py:118: in run
return self._loop.run_until_complete(task)
../../../miniconda3/envs/dask-distributed/lib/python3.11/asyncio/base_events.py:653: in run_until_complete
return future.result()
distributed/utils_test.py:375: in inner_fn
return await async_fn(*args, **kwargs)
distributed/utils_test.py:1097: in async_fn_outer
return await utils_wait_for(async_fn(), timeout=timeout * 2)
distributed/utils.py:1922: in wait_for
return await fut
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
async def async_fn():
result = None
with dask.config.set(config):
async with _cluster_factory() as (s, workers), _client_factory(
s
) as c:
args = [s] + workers
if c is not None:
args = [c] + args
try:
coro = func(*args, *outer_args, **kwargs)
task = asyncio.create_task(coro)
coro2 = utils_wait_for(
asyncio.shield(task), timeout=deadline.remaining
)
result = await coro2
validate_state(s, *workers)
except asyncio.TimeoutError:
assert task
elapsed = deadline.elapsed
buffer = io.StringIO()
# This stack indicates where the coro/test is suspended
task.print_stack(file=buffer)
if cluster_dump_directory:
await dump_cluster_state(
s=s,
ws=workers,
output_dir=cluster_dump_directory,
func_name=func.__name__,
)
task.cancel()
while not task.cancelled():
await asyncio.sleep(0.01)
# Hopefully, the hang has been caused by inconsistent
# state, which should be much more meaningful than the
# timeout
validate_state(s, *workers)
# Remove as much of the traceback as possible; it's
# uninteresting boilerplate from utils_test and asyncio
# and not from the code being tested.
raise asyncio.TimeoutError(
f"Test timeout ({timeout}) hit after {elapsed}s.\n"
"========== Test stack trace starts here ==========\n"
f"{buffer.getvalue()}"
) from None
except pytest.xfail.Exception:
raise
except Exception:
if cluster_dump_directory and not has_pytestmark(
test_func, "xfail"
):
await dump_cluster_state(
s=s,
ws=workers,
output_dir=cluster_dump_directory,
func_name=func.__name__,
)
raise
try:
c = default_client()
except ValueError:
pass
else:
await c._close(fast=True)
try:
unclosed = [c for c in Comm._instances if not c.closed()] + [
c for c in _global_clients.values() if c.status != "closed"
]
try:
if unclosed:
if allow_unclosed:
print(f"Unclosed Comms: {unclosed}")
else:
> raise RuntimeError("Unclosed Comms", unclosed)
E RuntimeError: ('Unclosed Comms', [<TCP (closed) ConnectionPool local=tcp://127.0.0.1:57589 remote=tcp://127.0.0.1:57580>])
distributed/utils_test.py:1076: RuntimeError
Check warning on line 0 in distributed.tests.test_scheduler
github-actions / Unit Test Results
3 out of 10 runs failed: test_ready_remove_worker[1.0] (distributed.tests.test_scheduler)
artifacts/macos-latest-3.11-queue-ci1/pytest.xml [took 0s]
artifacts/ubuntu-latest-3.11-queue-ci1/pytest.xml [took 0s]
artifacts/windows-latest-3.11-queue-ci1/pytest.xml [took 0s]
Raw output
RuntimeError: ('Unclosed Comms', [<TCP (closed) ConnectionPool local=tcp://127.0.0.1:57914 remote=tcp://127.0.0.1:57904>, <TCP (closed) ConnectionPool local=tcp://127.0.0.1:57913 remote=tcp://127.0.0.1:57904>])
args = (), kwds = {'worker_saturation': 1.0}
@wraps(func)
def inner(*args, **kwds):
with self._recreate_cm():
> return func(*args, **kwds)
../../../miniconda3/envs/dask-distributed/lib/python3.11/contextlib.py:81:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
../../../miniconda3/envs/dask-distributed/lib/python3.11/contextlib.py:81: in inner
return func(*args, **kwds)
distributed/utils_test.py:1100: in test_func
return _run_and_close_tornado(async_fn_outer)
distributed/utils_test.py:378: in _run_and_close_tornado
return asyncio_run(inner_fn(), loop_factory=get_loop_factory())
distributed/compatibility.py:204: in asyncio_run
return runner.run(main)
../../../miniconda3/envs/dask-distributed/lib/python3.11/asyncio/runners.py:118: in run
return self._loop.run_until_complete(task)
../../../miniconda3/envs/dask-distributed/lib/python3.11/asyncio/base_events.py:653: in run_until_complete
return future.result()
distributed/utils_test.py:375: in inner_fn
return await async_fn(*args, **kwargs)
distributed/utils_test.py:1097: in async_fn_outer
return await utils_wait_for(async_fn(), timeout=timeout * 2)
distributed/utils.py:1922: in wait_for
return await fut
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
async def async_fn():
result = None
with dask.config.set(config):
async with _cluster_factory() as (s, workers), _client_factory(
s
) as c:
args = [s] + workers
if c is not None:
args = [c] + args
try:
coro = func(*args, *outer_args, **kwargs)
task = asyncio.create_task(coro)
coro2 = utils_wait_for(
asyncio.shield(task), timeout=deadline.remaining
)
result = await coro2
validate_state(s, *workers)
except asyncio.TimeoutError:
assert task
elapsed = deadline.elapsed
buffer = io.StringIO()
# This stack indicates where the coro/test is suspended
task.print_stack(file=buffer)
if cluster_dump_directory:
await dump_cluster_state(
s=s,
ws=workers,
output_dir=cluster_dump_directory,
func_name=func.__name__,
)
task.cancel()
while not task.cancelled():
await asyncio.sleep(0.01)
# Hopefully, the hang has been caused by inconsistent
# state, which should be much more meaningful than the
# timeout
validate_state(s, *workers)
# Remove as much of the traceback as possible; it's
# uninteresting boilerplate from utils_test and asyncio
# and not from the code being tested.
raise asyncio.TimeoutError(
f"Test timeout ({timeout}) hit after {elapsed}s.\n"
"========== Test stack trace starts here ==========\n"
f"{buffer.getvalue()}"
) from None
except pytest.xfail.Exception:
raise
except Exception:
if cluster_dump_directory and not has_pytestmark(
test_func, "xfail"
):
await dump_cluster_state(
s=s,
ws=workers,
output_dir=cluster_dump_directory,
func_name=func.__name__,
)
raise
try:
c = default_client()
except ValueError:
pass
else:
await c._close(fast=True)
try:
unclosed = [c for c in Comm._instances if not c.closed()] + [
c for c in _global_clients.values() if c.status != "closed"
]
try:
if unclosed:
if allow_unclosed:
print(f"Unclosed Comms: {unclosed}")
else:
> raise RuntimeError("Unclosed Comms", unclosed)
E RuntimeError: ('Unclosed Comms', [<TCP (closed) ConnectionPool local=tcp://127.0.0.1:57914 remote=tcp://127.0.0.1:57904>, <TCP (closed) ConnectionPool local=tcp://127.0.0.1:57913 remote=tcp://127.0.0.1:57904>])
distributed/utils_test.py:1076: RuntimeError
Check warning on line 0 in distributed.tests.test_scheduler
github-actions / Unit Test Results
3 out of 10 runs failed: test_ready_remove_worker[inf] (distributed.tests.test_scheduler)
artifacts/macos-latest-3.11-queue-ci1/pytest.xml [took 0s]
artifacts/ubuntu-latest-3.11-queue-ci1/pytest.xml [took 0s]
artifacts/windows-latest-3.11-queue-ci1/pytest.xml [took 0s]
Raw output
RuntimeError: ('Unclosed Comms', [<TCP (closed) ConnectionPool local=tcp://127.0.0.1:57925 remote=tcp://127.0.0.1:57916>, <TCP (closed) ConnectionPool local=tcp://127.0.0.1:57926 remote=tcp://127.0.0.1:57916>])
args = (), kwds = {'worker_saturation': inf}
@wraps(func)
def inner(*args, **kwds):
with self._recreate_cm():
> return func(*args, **kwds)
../../../miniconda3/envs/dask-distributed/lib/python3.11/contextlib.py:81:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
../../../miniconda3/envs/dask-distributed/lib/python3.11/contextlib.py:81: in inner
return func(*args, **kwds)
distributed/utils_test.py:1100: in test_func
return _run_and_close_tornado(async_fn_outer)
distributed/utils_test.py:378: in _run_and_close_tornado
return asyncio_run(inner_fn(), loop_factory=get_loop_factory())
distributed/compatibility.py:204: in asyncio_run
return runner.run(main)
../../../miniconda3/envs/dask-distributed/lib/python3.11/asyncio/runners.py:118: in run
return self._loop.run_until_complete(task)
../../../miniconda3/envs/dask-distributed/lib/python3.11/asyncio/base_events.py:653: in run_until_complete
return future.result()
distributed/utils_test.py:375: in inner_fn
return await async_fn(*args, **kwargs)
distributed/utils_test.py:1097: in async_fn_outer
return await utils_wait_for(async_fn(), timeout=timeout * 2)
distributed/utils.py:1922: in wait_for
return await fut
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
async def async_fn():
result = None
with dask.config.set(config):
async with _cluster_factory() as (s, workers), _client_factory(
s
) as c:
args = [s] + workers
if c is not None:
args = [c] + args
try:
coro = func(*args, *outer_args, **kwargs)
task = asyncio.create_task(coro)
coro2 = utils_wait_for(
asyncio.shield(task), timeout=deadline.remaining
)
result = await coro2
validate_state(s, *workers)
except asyncio.TimeoutError:
assert task
elapsed = deadline.elapsed
buffer = io.StringIO()
# This stack indicates where the coro/test is suspended
task.print_stack(file=buffer)
if cluster_dump_directory:
await dump_cluster_state(
s=s,
ws=workers,
output_dir=cluster_dump_directory,
func_name=func.__name__,
)
task.cancel()
while not task.cancelled():
await asyncio.sleep(0.01)
# Hopefully, the hang has been caused by inconsistent
# state, which should be much more meaningful than the
# timeout
validate_state(s, *workers)
# Remove as much of the traceback as possible; it's
# uninteresting boilerplate from utils_test and asyncio
# and not from the code being tested.
raise asyncio.TimeoutError(
f"Test timeout ({timeout}) hit after {elapsed}s.\n"
"========== Test stack trace starts here ==========\n"
f"{buffer.getvalue()}"
) from None
except pytest.xfail.Exception:
raise
except Exception:
if cluster_dump_directory and not has_pytestmark(
test_func, "xfail"
):
await dump_cluster_state(
s=s,
ws=workers,
output_dir=cluster_dump_directory,
func_name=func.__name__,
)
raise
try:
c = default_client()
except ValueError:
pass
else:
await c._close(fast=True)
try:
unclosed = [c for c in Comm._instances if not c.closed()] + [
c for c in _global_clients.values() if c.status != "closed"
]
try:
if unclosed:
if allow_unclosed:
print(f"Unclosed Comms: {unclosed}")
else:
> raise RuntimeError("Unclosed Comms", unclosed)
E RuntimeError: ('Unclosed Comms', [<TCP (closed) ConnectionPool local=tcp://127.0.0.1:57925 remote=tcp://127.0.0.1:57916>, <TCP (closed) ConnectionPool local=tcp://127.0.0.1:57926 remote=tcp://127.0.0.1:57916>])
distributed/utils_test.py:1076: RuntimeError
Check warning on line 0 in distributed.tests.test_scheduler
github-actions / Unit Test Results
1 out of 10 runs failed: test_tell_workers_when_peers_have_left (distributed.tests.test_scheduler)
artifacts/ubuntu-latest-3.10-queue-ci1/pytest.xml [took 5s]
Raw output
assert 1690540780.6874702 < (1690540775.6656008 + 5)
+ where 1690540780.6874702 = time()
c = <Client: No scheduler connected>
s = <Scheduler 'tcp://127.0.0.1:46725', workers: 0, cores: 0, tasks: 0>
a = <Worker 'tcp://127.0.0.1:44911', name: 0, status: closed, stored: 0, running: 0/1, ready: 0, comm: 0, waiting: 0>
b = <Worker 'tcp://127.0.0.1:41567', name: 1, status: closed, stored: 1, running: 0/2, ready: 0, comm: 0, waiting: 0>
@gen_cluster(client=True)
async def test_tell_workers_when_peers_have_left(c, s, a, b):
f = (await c.scatter({"f": 1}, workers=[a.address, b.address], broadcast=True))["f"]
workers = {a.address: a, b.address: b}
connect_timeout = parse_timedelta(
dask.config.get("distributed.comm.timeouts.connect"), default="seconds"
)
class BrokenGatherDep(Worker):
async def gather_dep(self, worker, *args, **kwargs):
w = workers.pop(worker, None)
if w is not None and workers:
w.listener.stop()
s.stream_comms[worker].abort()
return await super().gather_dep(worker, *args, **kwargs)
async with BrokenGatherDep(s.address, nthreads=1) as w3:
start = time()
g = await c.submit(inc, f, key="g", workers=[w3.address])
# fails over to the second worker in less than the connect timeout
> assert time() < start + connect_timeout
E assert 1690540780.6874702 < (1690540775.6656008 + 5)
E + where 1690540780.6874702 = time()
distributed/tests/test_scheduler.py:4441: AssertionError
Check warning on line 0 in distributed.shuffle.tests.test_shuffle
github-actions / Unit Test Results
1 out of 7 runs failed: test_closed_worker_during_transfer (distributed.shuffle.tests.test_shuffle)
artifacts/windows-latest-3.9-queue-notci1/pytest.xml [took 13s]
Raw output
RuntimeError: shuffle_transfer failed during shuffle fc58bdda52fff94ba46954668b1c293d
> num_bytes = self.write_to_fd(self._write_buffer.peek(size))
C:\Miniconda3\envs\dask-distributed\lib\site-packages\tornado\iostream.py:962:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
> return self.socket.send(data) # type: ignore
E ConnectionResetError: [WinError 10054] An existing connection was forcibly closed by the remote host
C:\Miniconda3\envs\dask-distributed\lib\site-packages\tornado\iostream.py:1124: ConnectionResetError
The above exception was the direct cause of the following exception:
> return _get_worker_plugin().add_partition(
input,
shuffle_id=id,
type=ShuffleType.DATAFRAME,
partition_id=input_partition,
npartitions=npartitions,
column=column,
parts_out=parts_out,
)
distributed\shuffle\_shuffle.py:64:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
distributed\shuffle\_worker_plugin.py:669: in add_partition
return sync(
distributed\utils.py:426: in sync
raise exc.with_traceback(tb)
distributed\utils.py:399: in f
result = yield future
C:\Miniconda3\envs\dask-distributed\lib\site-packages\tornado\gen.py:767: in run
value = future.result()
distributed\shuffle\_worker_plugin.py:534: in add_partition
await self._write_to_comm(out)
distributed\shuffle\_worker_plugin.py:151: in _write_to_comm
await self._comm_buffer.write(data)
distributed\shuffle\_buffer.py:189: in write
raise self._exception
distributed\shuffle\_buffer.py:107: in process
await self._process(id, shards)
distributed\shuffle\_comms.py:72: in _process
await self.send(address, shards)
distributed\shuffle\_worker_plugin.py:122: in send
return await self.rpc(address).shuffle_receive(
distributed\core.py:1377: in send_recv_from_rpc
return await send_recv(comm=comm, op=key, **kwargs)
distributed\core.py:1136: in send_recv
response = await comm.read(deserializers=deserializers)
distributed\comm\tcp.py:241: in read
convert_stream_closed_error(self, e)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
> raise CommClosedError(f"in {obj}: {exc.__class__.__name__}: {exc}") from exc
E distributed.comm.core.CommClosedError: in <TCP (closed) ConnectionPool.shuffle_receive local=tcp://127.0.0.1:65298 remote=tcp://127.0.0.1:65289>: ConnectionResetError: [WinError 10054] An existing connection was forcibly closed by the remote host
distributed\comm\tcp.py:142: CommClosedError
The above exception was the direct cause of the following exception:
c = <Client: No scheduler connected>
s = <Scheduler 'tcp://127.0.0.1:65286', workers: 0, cores: 0, tasks: 0>
a = <Worker 'tcp://127.0.0.1:65287', name: 0, status: closed, stored: 0, running: 0/1, ready: 0, comm: 0, waiting: 0>
b = <Worker 'tcp://127.0.0.1:65289', name: 1, status: closed, stored: 2, running: 1/1, ready: 1, comm: 0, waiting: 0>
@gen_cluster(client=True, nthreads=[("", 1)] * 2)
async def test_closed_worker_during_transfer(c, s, a, b):
df = dask.datasets.timeseries(
start="2000-01-01",
end="2000-03-01",
dtypes={"x": float, "y": float},
freq="10 s",
)
out = dd.shuffle.shuffle(df, "x", shuffle="p2p")
x, y = c.compute([df.x.size, out.x.size])
await wait_for_tasks_in_state("shuffle-transfer", "memory", 1, b)
await b.close()
x = await x
> y = await y
distributed\shuffle\tests\test_shuffle.py:309:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
distributed\client.py:339: in _result
raise exc.with_traceback(tb)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
> raise RuntimeError(f"shuffle_transfer failed during shuffle {id}") from e
E RuntimeError: shuffle_transfer failed during shuffle fc58bdda52fff94ba46954668b1c293d
distributed\shuffle\_shuffle.py:76: RuntimeError
Check warning on line 0 in distributed.shuffle.tests.test_shuffle
github-actions / Unit Test Results
2 out of 7 runs failed: test_restarting_during_transfer_raises_killed_worker (distributed.shuffle.tests.test_shuffle)
artifacts/macos-latest-3.11-queue-notci1/pytest.xml [took 6s]
artifacts/windows-latest-3.11-queue-notci1/pytest.xml [took 8s]
Raw output
RuntimeError: shuffle_transfer failed during shuffle c05ba57851c759cbd2cc72838fa3facd
#
# Copyright 2009 Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""Utility classes to write to and read from non-blocking files and sockets.
Contents:
* `BaseIOStream`: Generic interface for reading and writing.
* `IOStream`: Implementation of BaseIOStream using non-blocking sockets.
* `SSLIOStream`: SSL-aware version of IOStream.
* `PipeIOStream`: Pipe-based IOStream implementation.
"""
import asyncio
import collections
import errno
import io
import numbers
import os
import socket
import ssl
import sys
import re
from tornado.concurrent import Future, future_set_result_unless_cancelled
from tornado import ioloop
from tornado.log import gen_log
from tornado.netutil import ssl_wrap_socket, _client_ssl_defaults, _server_ssl_defaults
from tornado.util import errno_from_exception
import typing
from typing import (
Union,
Optional,
Awaitable,
Callable,
Pattern,
Any,
Dict,
TypeVar,
Tuple,
)
from types import TracebackType
if typing.TYPE_CHECKING:
from typing import Deque, List, Type # noqa: F401
_IOStreamType = TypeVar("_IOStreamType", bound="IOStream")
# These errnos indicate that a connection has been abruptly terminated.
# They should be caught and handled less noisily than other errors.
_ERRNO_CONNRESET = (errno.ECONNRESET, errno.ECONNABORTED, errno.EPIPE, errno.ETIMEDOUT)
if hasattr(errno, "WSAECONNRESET"):
_ERRNO_CONNRESET += ( # type: ignore
errno.WSAECONNRESET, # type: ignore
errno.WSAECONNABORTED, # type: ignore
errno.WSAETIMEDOUT, # type: ignore
)
if sys.platform == "darwin":
# OSX appears to have a race condition that causes send(2) to return
# EPROTOTYPE if called while a socket is being torn down:
# http://erickt.github.io/blog/2014/11/19/adventures-in-debugging-a-potential-osx-kernel-bug/
# Since the socket is being closed anyway, treat this as an ECONNRESET
# instead of an unexpected error.
_ERRNO_CONNRESET += (errno.EPROTOTYPE,) # type: ignore
_WINDOWS = sys.platform.startswith("win")
class StreamClosedError(IOError):
"""Exception raised by `IOStream` methods when the stream is closed.
Note that the close callback is scheduled to run *after* other
callbacks on the stream (to allow for buffered data to be processed),
so you may see this error before you see the close callback.
The ``real_error`` attribute contains the underlying error that caused
the stream to close (if any).
.. versionchanged:: 4.3
Added the ``real_error`` attribute.
"""
def __init__(self, real_error: Optional[BaseException] = None) -> None:
super().__init__("Stream is closed")
self.real_error = real_error
class UnsatisfiableReadError(Exception):
"""Exception raised when a read cannot be satisfied.
Raised by ``read_until`` and ``read_until_regex`` with a ``max_bytes``
argument.
"""
pass
class StreamBufferFullError(Exception):
"""Exception raised by `IOStream` methods when the buffer is full."""
class _StreamBuffer(object):
"""
A specialized buffer that tries to avoid copies when large pieces
of data are encountered.
"""
def __init__(self) -> None:
# A sequence of (False, bytearray) and (True, memoryview) objects
self._buffers = (
collections.deque()
) # type: Deque[Tuple[bool, Union[bytearray, memoryview]]]
# Position in the first buffer
self._first_pos = 0
self._size = 0
def __len__(self) -> int:
return self._size
# Data above this size will be appended separately instead
# of extending an existing bytearray
_large_buf_threshold = 2048
def append(self, data: Union[bytes, bytearray, memoryview]) -> None:
"""
Append the given piece of data (should be a buffer-compatible object).
"""
size = len(data)
if size > self._large_buf_threshold:
if not isinstance(data, memoryview):
data = memoryview(data)
self._buffers.append((True, data))
elif size > 0:
if self._buffers:
is_memview, b = self._buffers[-1]
new_buf = is_memview or len(b) >= self._large_buf_threshold
else:
new_buf = True
if new_buf:
self._buffers.append((False, bytearray(data)))
else:
b += data # type: ignore
self._size += size
def peek(self, size: int) -> memoryview:
"""
Get a view over at most ``size`` bytes (possibly fewer) at the
current buffer position.
"""
assert size > 0
try:
is_memview, b = self._buffers[0]
except IndexError:
return memoryview(b"")
pos = self._first_pos
if is_memview:
return typing.cast(memoryview, b[pos : pos + size])
else:
return memoryview(b)[pos : pos + size]
def advance(self, size: int) -> None:
"""
Advance the current buffer position by ``size`` bytes.
"""
assert 0 < size <= self._size
self._size -= size
pos = self._first_pos
buffers = self._buffers
while buffers and size > 0:
is_large, b = buffers[0]
b_remain = len(b) - size - pos
if b_remain <= 0:
buffers.popleft()
size -= len(b) - pos
pos = 0
elif is_large:
pos += size
size = 0
else:
pos += size
del typing.cast(bytearray, b)[:pos]
pos = 0
size = 0
assert size == 0
self._first_pos = pos
class BaseIOStream(object):
"""A utility class to write to and read from a non-blocking file or socket.
We support a non-blocking ``write()`` and a family of ``read_*()``
methods. When the operation completes, the ``Awaitable`` will resolve
with the data read (or ``None`` for ``write()``). All outstanding
``Awaitables`` will resolve with a `StreamClosedError` when the
stream is closed; `.BaseIOStream.set_close_callback` can also be used
to be notified of a closed stream.
When a stream is closed due to an error, the IOStream's ``error``
attribute contains the exception object.
Subclasses must implement `fileno`, `close_fd`, `write_to_fd`,
`read_from_fd`, and optionally `get_fd_error`.
"""
def __init__(
self,
max_buffer_size: Optional[int] = None,
read_chunk_size: Optional[int] = None,
max_write_buffer_size: Optional[int] = None,
) -> None:
"""`BaseIOStream` constructor.
:arg max_buffer_size: Maximum amount of incoming data to buffer;
defaults to 100MB.
:arg read_chunk_size: Amount of data to read at one time from the
underlying transport; defaults to 64KB.
:arg max_write_buffer_size: Amount of outgoing data to buffer;
defaults to unlimited.
.. versionchanged:: 4.0
Add the ``max_write_buffer_size`` parameter. Changed default
``read_chunk_size`` to 64KB.
.. versionchanged:: 5.0
The ``io_loop`` argument (deprecated since version 4.1) has been
removed.
"""
self.io_loop = ioloop.IOLoop.current()
self.max_buffer_size = max_buffer_size or 104857600
# A chunk size that is too close to max_buffer_size can cause
# spurious failures.
self.read_chunk_size = min(read_chunk_size or 65536, self.max_buffer_size // 2)
self.max_write_buffer_size = max_write_buffer_size
self.error = None # type: Optional[BaseException]
self._read_buffer = bytearray()
self._read_buffer_size = 0
self._user_read_buffer = False
self._after_user_read_buffer = None # type: Optional[bytearray]
self._write_buffer = _StreamBuffer()
self._total_write_index = 0
self._total_write_done_index = 0
self._read_delimiter = None # type: Optional[bytes]
self._read_regex = None # type: Optional[Pattern]
self._read_max_bytes = None # type: Optional[int]
self._read_bytes = None # type: Optional[int]
self._read_partial = False
self._read_until_close = False
self._read_future = None # type: Optional[Future]
self._write_futures = (
collections.deque()
) # type: Deque[Tuple[int, Future[None]]]
self._close_callback = None # type: Optional[Callable[[], None]]
self._connect_future = None # type: Optional[Future[IOStream]]
# _ssl_connect_future should be defined in SSLIOStream
# but it's here so we can clean it up in _signal_closed
# TODO: refactor that so subclasses can add additional futures
# to be cancelled.
self._ssl_connect_future = None # type: Optional[Future[SSLIOStream]]
self._connecting = False
self._state = None # type: Optional[int]
self._closed = False
def fileno(self) -> Union[int, ioloop._Selectable]:
"""Returns the file descriptor for this stream."""
raise NotImplementedError()
def close_fd(self) -> None:
"""Closes the file underlying this stream.
``close_fd`` is called by `BaseIOStream` and should not be called
elsewhere; other users should call `close` instead.
"""
raise NotImplementedError()
def write_to_fd(self, data: memoryview) -> int:
"""Attempts to write ``data`` to the underlying file.
Returns the number of bytes written.
"""
raise NotImplementedError()
def read_from_fd(self, buf: Union[bytearray, memoryview]) -> Optional[int]:
"""Attempts to read from the underlying file.
Reads up to ``len(buf)`` bytes, storing them in the buffer.
Returns the number of bytes read. Returns None if there was
nothing to read (the socket returned `~errno.EWOULDBLOCK` or
equivalent), and zero on EOF.
.. versionchanged:: 5.0
Interface redesigned to take a buffer and return a number
of bytes instead of a freshly-allocated object.
"""
raise NotImplementedError()
def get_fd_error(self) -> Optional[Exception]:
"""Returns information about any error on the underlying file.
This method is called after the `.IOLoop` has signaled an error on the
file descriptor, and should return an Exception (such as `socket.error`
with additional information, or None if no such information is
available.
"""
return None
def read_until_regex(
self, regex: bytes, max_bytes: Optional[int] = None
) -> Awaitable[bytes]:
"""Asynchronously read until we have matched the given regex.
The result includes the data that matches the regex and anything
that came before it.
If ``max_bytes`` is not None, the connection will be closed
if more than ``max_bytes`` bytes have been read and the regex is
not satisfied.
.. versionchanged:: 4.0
Added the ``max_bytes`` argument. The ``callback`` argument is
now optional and a `.Future` will be returned if it is omitted.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
`.Future` instead.
"""
future = self._start_read()
self._read_regex = re.compile(regex)
self._read_max_bytes = max_bytes
try:
self._try_inline_read()
except UnsatisfiableReadError as e:
# Handle this the same way as in _handle_events.
gen_log.info("Unsatisfiable read, closing connection: %s" % e)
self.close(exc_info=e)
return future
except:
# Ensure that the future doesn't log an error because its
# failure was never examined.
future.add_done_callback(lambda f: f.exception())
raise
return future
def read_until(
self, delimiter: bytes, max_bytes: Optional[int] = None
) -> Awaitable[bytes]:
"""Asynchronously read until we have found the given delimiter.
The result includes all the data read including the delimiter.
If ``max_bytes`` is not None, the connection will be closed
if more than ``max_bytes`` bytes have been read and the delimiter
is not found.
.. versionchanged:: 4.0
Added the ``max_bytes`` argument. The ``callback`` argument is
now optional and a `.Future` will be returned if it is omitted.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
`.Future` instead.
"""
future = self._start_read()
self._read_delimiter = delimiter
self._read_max_bytes = max_bytes
try:
self._try_inline_read()
except UnsatisfiableReadError as e:
# Handle this the same way as in _handle_events.
gen_log.info("Unsatisfiable read, closing connection: %s" % e)
self.close(exc_info=e)
return future
except:
future.add_done_callback(lambda f: f.exception())
raise
return future
def read_bytes(self, num_bytes: int, partial: bool = False) -> Awaitable[bytes]:
"""Asynchronously read a number of bytes.
If ``partial`` is true, data is returned as soon as we have
any bytes to return (but never more than ``num_bytes``)
.. versionchanged:: 4.0
Added the ``partial`` argument. The callback argument is now
optional and a `.Future` will be returned if it is omitted.
.. versionchanged:: 6.0
The ``callback`` and ``streaming_callback`` arguments have
been removed. Use the returned `.Future` (and
``partial=True`` for ``streaming_callback``) instead.
"""
future = self._start_read()
assert isinstance(num_bytes, numbers.Integral)
self._read_bytes = num_bytes
self._read_partial = partial
try:
self._try_inline_read()
except:
future.add_done_callback(lambda f: f.exception())
raise
return future
def read_into(self, buf: bytearray, partial: bool = False) -> Awaitable[int]:
"""Asynchronously read a number of bytes.
``buf`` must be a writable buffer into which data will be read.
If ``partial`` is true, the callback is run as soon as any bytes
have been read. Otherwise, it is run when the ``buf`` has been
entirely filled with read data.
.. versionadded:: 5.0
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
`.Future` instead.
"""
future = self._start_read()
# First copy data already in read buffer
available_bytes = self._read_buffer_size
n = len(buf)
if available_bytes >= n:
buf[:] = memoryview(self._read_buffer)[:n]
del self._read_buffer[:n]
self._after_user_read_buffer = self._read_buffer
elif available_bytes > 0:
buf[:available_bytes] = memoryview(self._read_buffer)[:]
# Set up the supplied buffer as our temporary read buffer.
# The original (if it had any data remaining) has been
# saved for later.
self._user_read_buffer = True
self._read_buffer = buf
self._read_buffer_size = available_bytes
self._read_bytes = n
self._read_partial = partial
try:
self._try_inline_read()
except:
future.add_done_callback(lambda f: f.exception())
raise
return future
def read_until_close(self) -> Awaitable[bytes]:
"""Asynchronously reads all data from the socket until it is closed.
This will buffer all available data until ``max_buffer_size``
is reached. If flow control or cancellation are desired, use a
loop with `read_bytes(partial=True) <.read_bytes>` instead.
.. versionchanged:: 4.0
The callback argument is now optional and a `.Future` will
be returned if it is omitted.
.. versionchanged:: 6.0
The ``callback`` and ``streaming_callback`` arguments have
been removed. Use the returned `.Future` (and `read_bytes`
with ``partial=True`` for ``streaming_callback``) instead.
"""
future = self._start_read()
if self.closed():
self._finish_read(self._read_buffer_size)
return future
self._read_until_close = True
try:
self._try_inline_read()
except:
future.add_done_callback(lambda f: f.exception())
raise
return future
def write(self, data: Union[bytes, memoryview]) -> "Future[None]":
"""Asynchronously write the given data to this stream.
This method returns a `.Future` that resolves (with a result
of ``None``) when the write has been completed.
The ``data`` argument may be of type `bytes` or `memoryview`.
.. versionchanged:: 4.0
Now returns a `.Future` if no callback is given.
.. versionchanged:: 4.5
Added support for `memoryview` arguments.
.. versionchanged:: 6.0
The ``callback`` argument was removed. Use the returned
`.Future` instead.
"""
self._check_closed()
if data:
if isinstance(data, memoryview):
# Make sure that ``len(data) == data.nbytes``
data = memoryview(data).cast("B")
if (
self.max_write_buffer_size is not None
and len(self._write_buffer) + len(data) > self.max_write_buffer_size
):
raise StreamBufferFullError("Reached maximum write buffer size")
self._write_buffer.append(data)
self._total_write_index += len(data)
future = Future() # type: Future[None]
future.add_done_callback(lambda f: f.exception())
self._write_futures.append((self._total_write_index, future))
if not self._connecting:
self._handle_write()
if self._write_buffer:
self._add_io_state(self.io_loop.WRITE)
self._maybe_add_error_listener()
return future
def set_close_callback(self, callback: Optional[Callable[[], None]]) -> None:
"""Call the given callback when the stream is closed.
This mostly is not necessary for applications that use the
`.Future` interface; all outstanding ``Futures`` will resolve
with a `StreamClosedError` when the stream is closed. However,
it is still useful as a way to signal that the stream has been
closed while no other read or write is in progress.
Unlike other callback-based interfaces, ``set_close_callback``
was not removed in Tornado 6.0.
"""
self._close_callback = callback
self._maybe_add_error_listener()
def close(
self,
exc_info: Union[
None,
bool,
BaseException,
Tuple[
"Optional[Type[BaseException]]",
Optional[BaseException],
Optional[TracebackType],
],
] = False,
) -> None:
"""Close this stream.
If ``exc_info`` is true, set the ``error`` attribute to the current
exception from `sys.exc_info` (or if ``exc_info`` is a tuple,
use that instead of `sys.exc_info`).
"""
if not self.closed():
if exc_info:
if isinstance(exc_info, tuple):
self.error = exc_info[1]
elif isinstance(exc_info, BaseException):
self.error = exc_info
else:
exc_info = sys.exc_info()
if any(exc_info):
self.error = exc_info[1]
if self._read_until_close:
self._read_until_close = False
self._finish_read(self._read_buffer_size)
elif self._read_future is not None:
# resolve reads that are pending and ready to complete
try:
pos = self._find_read_pos()
except UnsatisfiableReadError:
pass
else:
if pos is not None:
self._read_from_buffer(pos)
if self._state is not None:
self.io_loop.remove_handler(self.fileno())
self._state = None
self.close_fd()
self._closed = True
self._signal_closed()
def _signal_closed(self) -> None:
futures = [] # type: List[Future]
if self._read_future is not None:
futures.append(self._read_future)
self._read_future = None
futures += [future for _, future in self._write_futures]
self._write_futures.clear()
if self._connect_future is not None:
futures.append(self._connect_future)
self._connect_future = None
for future in futures:
if not future.done():
future.set_exception(StreamClosedError(real_error=self.error))
# Reference the exception to silence warnings. Annoyingly,
# this raises if the future was cancelled, but just
# returns any other error.
try:
future.exception()
except asyncio.CancelledError:
pass
if self._ssl_connect_future is not None:
# _ssl_connect_future expects to see the real exception (typically
# an ssl.SSLError), not just StreamClosedError.
if not self._ssl_connect_future.done():
if self.error is not None:
self._ssl_connect_future.set_exception(self.error)
else:
self._ssl_connect_future.set_exception(StreamClosedError())
self._ssl_connect_future.exception()
self._ssl_connect_future = None
if self._close_callback is not None:
cb = self._close_callback
self._close_callback = None
self.io_loop.add_callback(cb)
# Clear the buffers so they can be cleared immediately even
# if the IOStream object is kept alive by a reference cycle.
# TODO: Clear the read buffer too; it currently breaks some tests.
self._write_buffer = None # type: ignore
def reading(self) -> bool:
"""Returns ``True`` if we are currently reading from the stream."""
return self._read_future is not None
def writing(self) -> bool:
"""Returns ``True`` if we are currently writing to the stream."""
return bool(self._write_buffer)
def closed(self) -> bool:
"""Returns ``True`` if the stream has been closed."""
return self._closed
def set_nodelay(self, value: bool) -> None:
"""Sets the no-delay flag for this stream.
By default, data written to TCP streams may be held for a time
to make the most efficient use of bandwidth (according to
Nagle's algorithm). The no-delay flag requests that data be
written as soon as possible, even if doing so would consume
additional bandwidth.
This flag is currently defined only for TCP-based ``IOStreams``.
.. versionadded:: 3.1
"""
pass
def _handle_connect(self) -> None:
raise NotImplementedError()
def _handle_events(self, fd: Union[int, ioloop._Selectable], events: int) -> None:
if self.closed():
gen_log.warning("Got events for closed stream %s", fd)
return
try:
if self._connecting:
# Most IOLoops will report a write failed connect
# with the WRITE event, but SelectIOLoop reports a
# READ as well so we must check for connecting before
# either.
self._handle_connect()
if self.closed():
return
if events & self.io_loop.READ:
self._handle_read()
if self.closed():
return
if events & self.io_loop.WRITE:
self._handle_write()
if self.closed():
return
if events & self.io_loop.ERROR:
self.error = self.get_fd_error()
# We may have queued up a user callback in _handle_read or
# _handle_write, so don't close the IOStream until those
# callbacks have had a chance to run.
self.io_loop.add_callback(self.close)
return
state = self.io_loop.ERROR
if self.reading():
state |= self.io_loop.READ
if self.writing():
state |= self.io_loop.WRITE
if state == self.io_loop.ERROR and self._read_buffer_size == 0:
# If the connection is idle, listen for reads too so
# we can tell if the connection is closed. If there is
# data in the read buffer we won't run the close callback
# yet anyway, so we don't need to listen in this case.
state |= self.io_loop.READ
if state != self._state:
assert (
self._state is not None
), "shouldn't happen: _handle_events without self._state"
self._state = state
self.io_loop.update_handler(self.fileno(), self._state)
except UnsatisfiableReadError as e:
gen_log.info("Unsatisfiable read, closing connection: %s" % e)
self.close(exc_info=e)
except Exception as e:
gen_log.error("Uncaught exception, closing connection.", exc_info=True)
self.close(exc_info=e)
raise
def _read_to_buffer_loop(self) -> Optional[int]:
# This method is called from _handle_read and _try_inline_read.
if self._read_bytes is not None:
target_bytes = self._read_bytes # type: Optional[int]
elif self._read_max_bytes is not None:
target_bytes = self._read_max_bytes
elif self.reading():
# For read_until without max_bytes, or
# read_until_close, read as much as we can before
# scanning for the delimiter.
target_bytes = None
else:
target_bytes = 0
next_find_pos = 0
while not self.closed():
# Read from the socket until we get EWOULDBLOCK or equivalent.
# SSL sockets do some internal buffering, and if the data is
# sitting in the SSL object's buffer select() and friends
# can't see it; the only way to find out if it's there is to
# try to read it.
if self._read_to_buffer() == 0:
break
# If we've read all the bytes we can use, break out of
# this loop.
# If we've reached target_bytes, we know we're done.
if target_bytes is not None and self._read_buffer_size >= target_bytes:
break
# Otherwise, we need to call the more expensive find_read_pos.
# It's inefficient to do this on every read, so instead
# do it on the first read and whenever the read buffer
# size has doubled.
if self._read_buffer_size >= next_find_pos:
pos = self._find_read_pos()
if pos is not None:
return pos
next_find_pos = self._read_buffer_size * 2
return self._find_read_pos()
def _handle_read(self) -> None:
try:
pos = self._read_to_buffer_loop()
except UnsatisfiableReadError:
… self._state = state
self.io_loop.update_handler(self.fileno(), self._state)
except UnsatisfiableReadError as e:
gen_log.info("Unsatisfiable read, closing connection: %s" % e)
self.close(exc_info=e)
except Exception as e:
gen_log.error("Uncaught exception, closing connection.", exc_info=True)
self.close(exc_info=e)
raise
def _read_to_buffer_loop(self) -> Optional[int]:
# This method is called from _handle_read and _try_inline_read.
if self._read_bytes is not None:
target_bytes = self._read_bytes # type: Optional[int]
elif self._read_max_bytes is not None:
target_bytes = self._read_max_bytes
elif self.reading():
# For read_until without max_bytes, or
# read_until_close, read as much as we can before
# scanning for the delimiter.
target_bytes = None
else:
target_bytes = 0
next_find_pos = 0
while not self.closed():
# Read from the socket until we get EWOULDBLOCK or equivalent.
# SSL sockets do some internal buffering, and if the data is
# sitting in the SSL object's buffer select() and friends
# can't see it; the only way to find out if it's there is to
# try to read it.
if self._read_to_buffer() == 0:
break
# If we've read all the bytes we can use, break out of
# this loop.
# If we've reached target_bytes, we know we're done.
if target_bytes is not None and self._read_buffer_size >= target_bytes:
break
# Otherwise, we need to call the more expensive find_read_pos.
# It's inefficient to do this on every read, so instead
# do it on the first read and whenever the read buffer
# size has doubled.
if self._read_buffer_size >= next_find_pos:
pos = self._find_read_pos()
if pos is not None:
return pos
next_find_pos = self._read_buffer_size * 2
return self._find_read_pos()
def _handle_read(self) -> None:
try:
pos = self._read_to_buffer_loop()
except UnsatisfiableReadError:
raise
except asyncio.CancelledError:
raise
except Exception as e:
gen_log.warning("error on read: %s" % e)
self.close(exc_info=e)
return
if pos is not None:
self._read_from_buffer(pos)
def _start_read(self) -> Future:
if self._read_future is not None:
# It is an error to start a read while a prior read is unresolved.
# However, if the prior read is unresolved because the stream was
# closed without satisfying it, it's better to raise
# StreamClosedError instead of AssertionError. In particular, this
# situation occurs in harmless situations in http1connection.py and
# an AssertionError would be logged noisily.
#
# On the other hand, it is legal to start a new read while the
# stream is closed, in case the read can be satisfied from the
# read buffer. So we only want to check the closed status of the
# stream if we need to decide what kind of error to raise for
# "already reading".
#
# These conditions have proven difficult to test; we have no
# unittests that reliably verify this behavior so be careful
# when making changes here. See #2651 and #2719.
self._check_closed()
assert self._read_future is None, "Already reading"
self._read_future = Future()
return self._read_future
def _finish_read(self, size: int) -> None:
if self._user_read_buffer:
self._read_buffer = self._after_user_read_buffer or bytearray()
self._after_user_read_buffer = None
self._read_buffer_size = len(self._read_buffer)
self._user_read_buffer = False
result = size # type: Union[int, bytes]
else:
result = self._consume(size)
if self._read_future is not None:
future = self._read_future
self._read_future = None
future_set_result_unless_cancelled(future, result)
self._maybe_add_error_listener()
def _try_inline_read(self) -> None:
"""Attempt to complete the current read operation from buffered data.
If the read can be completed without blocking, schedules the
read callback on the next IOLoop iteration; otherwise starts
listening for reads on the socket.
"""
# See if we've already got the data from a previous read
pos = self._find_read_pos()
if pos is not None:
self._read_from_buffer(pos)
return
self._check_closed()
pos = self._read_to_buffer_loop()
if pos is not None:
self._read_from_buffer(pos)
return
# We couldn't satisfy the read inline, so make sure we're
# listening for new data unless the stream is closed.
if not self.closed():
self._add_io_state(ioloop.IOLoop.READ)
def _read_to_buffer(self) -> Optional[int]:
"""Reads from the socket and appends the result to the read buffer.
Returns the number of bytes read. Returns 0 if there is nothing
to read (i.e. the read returns EWOULDBLOCK or equivalent). On
error closes the socket and raises an exception.
"""
try:
while True:
try:
if self._user_read_buffer:
buf = memoryview(self._read_buffer)[
self._read_buffer_size :
] # type: Union[memoryview, bytearray]
else:
buf = bytearray(self.read_chunk_size)
bytes_read = self.read_from_fd(buf)
except (socket.error, IOError, OSError) as e:
# ssl.SSLError is a subclass of socket.error
if self._is_connreset(e):
# Treat ECONNRESET as a connection close rather than
# an error to minimize log spam (the exception will
# be available on self.error for apps that care).
self.close(exc_info=e)
return None
self.close(exc_info=e)
raise
break
if bytes_read is None:
return 0
elif bytes_read == 0:
self.close()
return 0
if not self._user_read_buffer:
self._read_buffer += memoryview(buf)[:bytes_read]
self._read_buffer_size += bytes_read
finally:
# Break the reference to buf so we don't waste a chunk's worth of
# memory in case an exception hangs on to our stack frame.
del buf
if self._read_buffer_size > self.max_buffer_size:
gen_log.error("Reached maximum read buffer size")
self.close()
raise StreamBufferFullError("Reached maximum read buffer size")
return bytes_read
def _read_from_buffer(self, pos: int) -> None:
"""Attempts to complete the currently-pending read from the buffer.
The argument is either a position in the read buffer or None,
as returned by _find_read_pos.
"""
self._read_bytes = self._read_delimiter = self._read_regex = None
self._read_partial = False
self._finish_read(pos)
def _find_read_pos(self) -> Optional[int]:
"""Attempts to find a position in the read buffer that satisfies
the currently-pending read.
Returns a position in the buffer if the current read can be satisfied,
or None if it cannot.
"""
if self._read_bytes is not None and (
self._read_buffer_size >= self._read_bytes
or (self._read_partial and self._read_buffer_size > 0)
):
num_bytes = min(self._read_bytes, self._read_buffer_size)
return num_bytes
elif self._read_delimiter is not None:
# Multi-byte delimiters (e.g. '\r\n') may straddle two
# chunks in the read buffer, so we can't easily find them
# without collapsing the buffer. However, since protocols
# using delimited reads (as opposed to reads of a known
# length) tend to be "line" oriented, the delimiter is likely
# to be in the first few chunks. Merge the buffer gradually
# since large merges are relatively expensive and get undone in
# _consume().
if self._read_buffer:
loc = self._read_buffer.find(self._read_delimiter)
if loc != -1:
delimiter_len = len(self._read_delimiter)
self._check_max_bytes(self._read_delimiter, loc + delimiter_len)
return loc + delimiter_len
self._check_max_bytes(self._read_delimiter, self._read_buffer_size)
elif self._read_regex is not None:
if self._read_buffer:
m = self._read_regex.search(self._read_buffer)
if m is not None:
loc = m.end()
self._check_max_bytes(self._read_regex, loc)
return loc
self._check_max_bytes(self._read_regex, self._read_buffer_size)
return None
def _check_max_bytes(self, delimiter: Union[bytes, Pattern], size: int) -> None:
if self._read_max_bytes is not None and size > self._read_max_bytes:
raise UnsatisfiableReadError(
"delimiter %r not found within %d bytes"
% (delimiter, self._read_max_bytes)
)
def _handle_write(self) -> None:
while True:
size = len(self._write_buffer)
if not size:
break
assert size > 0
try:
if _WINDOWS:
# On windows, socket.send blows up if given a
# write buffer that's too large, instead of just
# returning the number of bytes it was able to
# process. Therefore we must not call socket.send
# with more than 128KB at a time.
size = 128 * 1024
num_bytes = self.write_to_fd(self._write_buffer.peek(size))
if num_bytes == 0:
break
self._write_buffer.advance(num_bytes)
self._total_write_done_index += num_bytes
except BlockingIOError:
break
except (socket.error, IOError, OSError) as e:
if not self._is_connreset(e):
# Broken pipe errors are usually caused by connection
# reset, and its better to not log EPIPE errors to
# minimize log spam
gen_log.warning("Write error on %s: %s", self.fileno(), e)
self.close(exc_info=e)
return
while self._write_futures:
index, future = self._write_futures[0]
if index > self._total_write_done_index:
break
self._write_futures.popleft()
future_set_result_unless_cancelled(future, None)
def _consume(self, loc: int) -> bytes:
# Consume loc bytes from the read buffer and return them
if loc == 0:
return b""
assert loc <= self._read_buffer_size
# Slice the bytearray buffer into bytes, without intermediate copying
b = (memoryview(self._read_buffer)[:loc]).tobytes()
self._read_buffer_size -= loc
del self._read_buffer[:loc]
return b
def _check_closed(self) -> None:
if self.closed():
raise StreamClosedError(real_error=self.error)
def _maybe_add_error_listener(self) -> None:
# This method is part of an optimization: to detect a connection that
# is closed when we're not actively reading or writing, we must listen
# for read events. However, it is inefficient to do this when the
# connection is first established because we are going to read or write
# immediately anyway. Instead, we insert checks at various times to
# see if the connection is idle and add the read listener then.
if self._state is None or self._state == ioloop.IOLoop.ERROR:
if (
not self.closed()
and self._read_buffer_size == 0
and self._close_callback is not None
):
self._add_io_state(ioloop.IOLoop.READ)
def _add_io_state(self, state: int) -> None:
"""Adds `state` (IOLoop.{READ,WRITE} flags) to our event handler.
Implementation notes: Reads and writes have a fast path and a
slow path. The fast path reads synchronously from socket
buffers, while the slow path uses `_add_io_state` to schedule
an IOLoop callback.
To detect closed connections, we must have called
`_add_io_state` at some point, but we want to delay this as
much as possible so we don't have to set an `IOLoop.ERROR`
listener that will be overwritten by the next slow-path
operation. If a sequence of fast-path ops do not end in a
slow-path op, (e.g. for an @asynchronous long-poll request),
we must add the error handler.
TODO: reevaluate this now that callbacks are gone.
"""
if self.closed():
# connection has been closed, so there can be no future events
return
if self._state is None:
self._state = ioloop.IOLoop.ERROR | state
self.io_loop.add_handler(self.fileno(), self._handle_events, self._state)
elif not self._state & state:
self._state = self._state | state
self.io_loop.update_handler(self.fileno(), self._state)
def _is_connreset(self, exc: BaseException) -> bool:
"""Return ``True`` if exc is ECONNRESET or equivalent.
May be overridden in subclasses.
"""
return (
isinstance(exc, (socket.error, IOError))
and errno_from_exception(exc) in _ERRNO_CONNRESET
)
class IOStream(BaseIOStream):
r"""Socket-based `IOStream` implementation.
This class supports the read and write methods from `BaseIOStream`
plus a `connect` method.
The ``socket`` parameter may either be connected or unconnected.
For server operations the socket is the result of calling
`socket.accept <socket.socket.accept>`. For client operations the
socket is created with `socket.socket`, and may either be
connected before passing it to the `IOStream` or connected with
`IOStream.connect`.
A very simple (and broken) HTTP client using this class:
.. testcode::
import socket
import tornado
async def main():
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
stream = tornado.iostream.IOStream(s)
await stream.connect(("friendfeed.com", 80))
await stream.write(b"GET / HTTP/1.0\r\nHost: friendfeed.com\r\n\r\n")
header_data = await stream.read_until(b"\r\n\r\n")
headers = {}
for line in header_data.split(b"\r\n"):
parts = line.split(b":")
if len(parts) == 2:
headers[parts[0].strip()] = parts[1].strip()
body_data = await stream.read_bytes(int(headers[b"Content-Length"]))
print(body_data)
stream.close()
if __name__ == '__main__':
asyncio.run(main())
.. testoutput::
:hide:
"""
def __init__(self, socket: socket.socket, *args: Any, **kwargs: Any) -> None:
self.socket = socket
self.socket.setblocking(False)
super().__init__(*args, **kwargs)
def fileno(self) -> Union[int, ioloop._Selectable]:
return self.socket
def close_fd(self) -> None:
self.socket.close()
self.socket = None # type: ignore
def get_fd_error(self) -> Optional[Exception]:
errno = self.socket.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR)
return socket.error(errno, os.strerror(errno))
def read_from_fd(self, buf: Union[bytearray, memoryview]) -> Optional[int]:
try:
> return self.socket.recv_into(buf, len(buf))
E ConnectionResetError: [WinError 10054] An existing connection was forcibly closed by the remote host
C:\Miniconda3\envs\dask-distributed\Lib\site-packages\tornado\iostream.py:1116: ConnectionResetError
The above exception was the direct cause of the following exception:
from __future__ import annotations
import logging
from collections.abc import Iterable, Iterator
from enum import Enum
from typing import TYPE_CHECKING, Any, NewType, Union
from dask.base import tokenize
from dask.highlevelgraph import HighLevelGraph
from dask.layers import Layer
from distributed.exceptions import Reschedule
from distributed.shuffle._arrow import check_dtype_support, check_minimal_arrow_version
from distributed.shuffle._exceptions import ShuffleClosedError
logger = logging.getLogger("distributed.shuffle")
if TYPE_CHECKING:
import pandas as pd
# TODO import from typing (requires Python >=3.10)
from typing_extensions import TypeAlias
from dask.dataframe import DataFrame
# circular dependency
from distributed.shuffle._worker_plugin import ShuffleWorkerPlugin
ShuffleId = NewType("ShuffleId", str)
class ShuffleType(Enum):
DATAFRAME = "DataFrameShuffle"
ARRAY_RECHUNK = "ArrayRechunk"
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
plugin: ShuffleWorkerPlugin | None = worker.plugins.get("shuffle") # type: ignore
if plugin is None:
raise RuntimeError(
f"The worker {worker.address} does not have a ShuffleExtension. "
"Is pandas installed on the worker?"
)
return plugin
def shuffle_transfer(
input: pd.DataFrame,
id: ShuffleId,
input_partition: int,
npartitions: int,
column: str,
parts_out: set[int],
) -> int:
try:
> return _get_worker_plugin().add_partition(
input,
shuffle_id=id,
type=ShuffleType.DATAFRAME,
partition_id=input_partition,
npartitions=npartitions,
column=column,
parts_out=parts_out,
)
distributed\shuffle\_shuffle.py:64:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
distributed\shuffle\_worker_plugin.py:669: in add_partition
return sync(
distributed\utils.py:426: in sync
raise exc.with_traceback(tb)
distributed\utils.py:399: in f
result = yield future
C:\Miniconda3\envs\dask-distributed\Lib\site-packages\tornado\gen.py:767: in run
value = future.result()
distributed\shuffle\_worker_plugin.py:534: in add_partition
await self._write_to_comm(out)
distributed\shuffle\_worker_plugin.py:151: in _write_to_comm
await self._comm_buffer.write(data)
distributed\shuffle\_buffer.py:189: in write
raise self._exception
distributed\shuffle\_buffer.py:107: in process
await self._process(id, shards)
distributed\shuffle\_comms.py:72: in _process
await self.send(address, shards)
distributed\shuffle\_worker_plugin.py:122: in send
return await self.rpc(address).shuffle_receive(
distributed\core.py:1377: in send_recv_from_rpc
return await send_recv(comm=comm, op=key, **kwargs)
distributed\core.py:1136: in send_recv
response = await comm.read(deserializers=deserializers)
distributed\comm\tcp.py:241: in read
convert_stream_closed_error(self, e)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
from __future__ import annotations
import asyncio
import ctypes
import errno
import functools
import logging
import socket
import ssl
import struct
import sys
import weakref
from ssl import SSLCertVerificationError, SSLError
from typing import Any, ClassVar
from tlz import sliding_window
from tornado import gen, netutil
from tornado.iostream import IOStream, StreamClosedError
from tornado.tcpclient import TCPClient
from tornado.tcpserver import TCPServer
import dask
from dask.utils import parse_timedelta
from distributed.comm.addressing import parse_host_port, unparse_host_port
from distributed.comm.core import (
BaseListener,
Comm,
CommClosedError,
Connector,
FatalCommClosedError,
)
from distributed.comm.registry import Backend
from distributed.comm.utils import (
ensure_concrete_host,
from_frames,
get_tcp_server_address,
host_array,
to_frames,
)
from distributed.protocol.utils import pack_frames_prelude, unpack_frames
from distributed.system import MEMORY_LIMIT
from distributed.utils import ensure_ip, ensure_memoryview, get_ip, get_ipv6, nbytes
logger = logging.getLogger(__name__)
# Workaround for OpenSSL 1.0.2.
# Can drop with OpenSSL 1.1.1 used by Python 3.10+.
# ref: https://bugs.python.org/issue42853
if sys.version_info < (3, 10):
OPENSSL_MAX_CHUNKSIZE = 256 ** ctypes.sizeof(ctypes.c_int) // 2 - 1
else:
OPENSSL_MAX_CHUNKSIZE = 256 ** ctypes.sizeof(ctypes.c_size_t) - 1
MAX_BUFFER_SIZE = MEMORY_LIMIT / 2
def set_tcp_timeout(comm):
"""
Set kernel-level TCP timeout on the stream.
"""
if comm.closed():
return
timeout = dask.config.get("distributed.comm.timeouts.tcp")
timeout = int(parse_timedelta(timeout, default="seconds"))
sock = comm.socket
# Default (unsettable) value on Windows
# https://msdn.microsoft.com/en-us/library/windows/desktop/dd877220(v=vs.85).aspx
nprobes = 10
assert timeout >= nprobes + 1, "Timeout too low"
idle = max(2, timeout // 4)
interval = max(1, (timeout - idle) // nprobes)
idle = timeout - interval * nprobes
assert idle > 0
try:
if sys.platform.startswith("win"):
logger.debug("Setting TCP keepalive: idle=%d, interval=%d", idle, interval)
sock.ioctl(socket.SIO_KEEPALIVE_VALS, (1, idle * 1000, interval * 1000))
else:
sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
try:
TCP_KEEPIDLE = socket.TCP_KEEPIDLE
TCP_KEEPINTVL = socket.TCP_KEEPINTVL
TCP_KEEPCNT = socket.TCP_KEEPCNT
except AttributeError:
if sys.platform == "darwin":
TCP_KEEPIDLE = 0x10 # (named "TCP_KEEPALIVE" in C)
TCP_KEEPINTVL = 0x101
TCP_KEEPCNT = 0x102
else:
TCP_KEEPIDLE = None
if TCP_KEEPIDLE is not None:
logger.debug(
"Setting TCP keepalive: nprobes=%d, idle=%d, interval=%d",
nprobes,
idle,
interval,
)
sock.setsockopt(socket.SOL_TCP, TCP_KEEPCNT, nprobes)
sock.setsockopt(socket.SOL_TCP, TCP_KEEPIDLE, idle)
sock.setsockopt(socket.SOL_TCP, TCP_KEEPINTVL, interval)
if sys.platform.startswith("linux"):
logger.debug("Setting TCP user timeout: %d ms", timeout * 1000)
TCP_USER_TIMEOUT = 18 # since Linux 2.6.37
sock.setsockopt(socket.SOL_TCP, TCP_USER_TIMEOUT, timeout * 1000)
except OSError:
logger.exception("Could not set timeout on TCP stream.")
def get_stream_address(comm):
"""
Get a stream's local address.
"""
if comm.closed():
return "<closed>"
try:
return unparse_host_port(*comm.socket.getsockname()[:2])
except OSError:
# Probably EBADF
return "<closed>"
def convert_stream_closed_error(obj, exc):
"""
Re-raise StreamClosedError as CommClosedError.
"""
if exc.real_error is not None:
# The stream was closed because of an underlying OS error
exc = exc.real_error
if isinstance(exc, ssl.SSLError):
if exc.reason and "UNKNOWN_CA" in exc.reason:
raise FatalCommClosedError(f"in {obj}: {exc.__class__.__name__}: {exc}")
> raise CommClosedError(f"in {obj}: {exc.__class__.__name__}: {exc}") from exc
E distributed.comm.core.CommClosedError: in <TCP (closed) ConnectionPool.shuffle_receive local=tcp://127.0.0.1:55236 remote=tcp://127.0.0.1:55228>: ConnectionResetError: [WinError 10054] An existing connection was forcibly closed by the remote host
distributed\comm\tcp.py:142: CommClosedError
The above exception was the direct cause of the following exception:
c = <Client: No scheduler connected>
s = <Scheduler 'tcp://127.0.0.1:55224', workers: 0, cores: 0, tasks: 0>
a = <Worker 'tcp://127.0.0.1:55225', name: 0, status: closed, stored: 0, running: 0/1, ready: 0, comm: 0, waiting: 0>
b = <Worker 'tcp://127.0.0.1:55228', name: 1, status: closed, stored: 0, running: 1/1, ready: 0, comm: 0, waiting: 0>
@gen_cluster(
client=True,
nthreads=[("", 1)] * 2,
config={"distributed.scheduler.allowed-failures": 0},
)
async def test_restarting_during_transfer_raises_killed_worker(c, s, a, b):
df = dask.datasets.timeseries(
start="2000-01-01",
end="2000-03-01",
dtypes={"x": float, "y": float},
freq="10 s",
)
out = dd.shuffle.shuffle(df, "x", shuffle="p2p")
out = c.compute(out.x.size)
await wait_for_tasks_in_state("shuffle-transfer", "memory", 1, b)
await b.close()
with pytest.raises(KilledWorker):
> await out
distributed\shuffle\tests\test_shuffle.py:336:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
distributed\client.py:339: in _result
raise exc.with_traceback(tb)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
from __future__ import annotations
import logging
from collections.abc import Iterable, Iterator
from enum import Enum
from typing import TYPE_CHECKING, Any, NewType, Union
from dask.base import tokenize
from dask.highlevelgraph import HighLevelGraph
from dask.layers import Layer
from distributed.exceptions import Reschedule
from distributed.shuffle._arrow import check_dtype_support, check_minimal_arrow_version
from distributed.shuffle._exceptions import ShuffleClosedError
logger = logging.getLogger("distributed.shuffle")
if TYPE_CHECKING:
import pandas as pd
# TODO import from typing (requires Python >=3.10)
from typing_extensions import TypeAlias
from dask.dataframe import DataFrame
# circular dependency
from distributed.shuffle._worker_plugin import ShuffleWorkerPlugin
ShuffleId = NewType("ShuffleId", str)
class ShuffleType(Enum):
DATAFRAME = "DataFrameShuffle"
ARRAY_RECHUNK = "ArrayRechunk"
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
plugin: ShuffleWorkerPlugin | None = worker.plugins.get("shuffle") # type: ignore
if plugin is None:
raise RuntimeError(
f"The worker {worker.address} does not have a ShuffleExtension. "
"Is pandas installed on the worker?"
)
return plugin
def shuffle_transfer(
input: pd.DataFrame,
id: ShuffleId,
input_partition: int,
npartitions: int,
column: str,
parts_out: set[int],
) -> int:
try:
return _get_worker_plugin().add_partition(
input,
shuffle_id=id,
type=ShuffleType.DATAFRAME,
partition_id=input_partition,
npartitions=npartitions,
column=column,
parts_out=parts_out,
)
except ShuffleClosedError:
raise Reschedule()
except Exception as e:
> raise RuntimeError(f"shuffle_transfer failed during shuffle {id}") from e
E RuntimeError: shuffle_transfer failed during shuffle c05ba57851c759cbd2cc72838fa3facd
distributed\shuffle\_shuffle.py:76: RuntimeError
Check warning on line 0 in distributed.shuffle.tests.test_shuffle
github-actions / Unit Test Results
1 out of 7 runs failed: test_closed_input_only_worker_during_transfer (distributed.shuffle.tests.test_shuffle)
artifacts/windows-latest-3.9-queue-notci1/pytest.xml [took 1m 1s]
Raw output
asyncio.exceptions.TimeoutError
fut = <Future cancelled>, timeout = 29.927342653274536
async def wait_for(fut, timeout, *, loop=None):
"""Wait for the single Future or coroutine to complete, with timeout.
Coroutine will be wrapped in Task.
Returns result of the Future or coroutine. When a timeout occurs,
it cancels the task and raises TimeoutError. To avoid the task
cancellation, wrap it in shield().
If the wait is cancelled, the task is also cancelled.
This function is a coroutine.
"""
if loop is None:
loop = events.get_running_loop()
else:
warnings.warn("The loop argument is deprecated since Python 3.8, "
"and scheduled for removal in Python 3.10.",
DeprecationWarning, stacklevel=2)
if timeout is None:
return await fut
if timeout <= 0:
fut = ensure_future(fut, loop=loop)
if fut.done():
return fut.result()
await _cancel_and_wait(fut, loop=loop)
try:
return fut.result()
except exceptions.CancelledError as exc:
raise exceptions.TimeoutError() from exc
waiter = loop.create_future()
timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
cb = functools.partial(_release_waiter, waiter)
fut = ensure_future(fut, loop=loop)
fut.add_done_callback(cb)
try:
# wait until the future completes or the timeout
try:
await waiter
except exceptions.CancelledError:
if fut.done():
return fut.result()
else:
fut.remove_done_callback(cb)
# We must ensure that the task is not running
# after wait_for() returns.
# See https://bugs.python.org/issue32751
await _cancel_and_wait(fut, loop=loop)
raise
if fut.done():
return fut.result()
else:
fut.remove_done_callback(cb)
# We must ensure that the task is not running
# after wait_for() returns.
# See https://bugs.python.org/issue32751
await _cancel_and_wait(fut, loop=loop)
# In case task cancellation failed with some
# exception, we should re-raise it
# See https://bugs.python.org/issue40607
try:
> return fut.result()
E asyncio.exceptions.CancelledError
C:\Miniconda3\envs\dask-distributed\lib\asyncio\tasks.py:490: CancelledError
The above exception was the direct cause of the following exception:
async def async_fn():
result = None
with dask.config.set(config):
async with _cluster_factory() as (s, workers), _client_factory(
s
) as c:
args = [s] + workers
if c is not None:
args = [c] + args
try:
coro = func(*args, *outer_args, **kwargs)
task = asyncio.create_task(coro)
coro2 = utils_wait_for(
asyncio.shield(task), timeout=deadline.remaining
)
> result = await coro2
distributed\utils_test.py:1009:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
distributed\utils.py:1927: in wait_for
return await asyncio.wait_for(fut, timeout)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
fut = <Future cancelled>, timeout = 29.927342653274536
async def wait_for(fut, timeout, *, loop=None):
"""Wait for the single Future or coroutine to complete, with timeout.
Coroutine will be wrapped in Task.
Returns result of the Future or coroutine. When a timeout occurs,
it cancels the task and raises TimeoutError. To avoid the task
cancellation, wrap it in shield().
If the wait is cancelled, the task is also cancelled.
This function is a coroutine.
"""
if loop is None:
loop = events.get_running_loop()
else:
warnings.warn("The loop argument is deprecated since Python 3.8, "
"and scheduled for removal in Python 3.10.",
DeprecationWarning, stacklevel=2)
if timeout is None:
return await fut
if timeout <= 0:
fut = ensure_future(fut, loop=loop)
if fut.done():
return fut.result()
await _cancel_and_wait(fut, loop=loop)
try:
return fut.result()
except exceptions.CancelledError as exc:
raise exceptions.TimeoutError() from exc
waiter = loop.create_future()
timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
cb = functools.partial(_release_waiter, waiter)
fut = ensure_future(fut, loop=loop)
fut.add_done_callback(cb)
try:
# wait until the future completes or the timeout
try:
await waiter
except exceptions.CancelledError:
if fut.done():
return fut.result()
else:
fut.remove_done_callback(cb)
# We must ensure that the task is not running
# after wait_for() returns.
# See https://bugs.python.org/issue32751
await _cancel_and_wait(fut, loop=loop)
raise
if fut.done():
return fut.result()
else:
fut.remove_done_callback(cb)
# We must ensure that the task is not running
# after wait_for() returns.
# See https://bugs.python.org/issue32751
await _cancel_and_wait(fut, loop=loop)
# In case task cancellation failed with some
# exception, we should re-raise it
# See https://bugs.python.org/issue40607
try:
return fut.result()
except exceptions.CancelledError as exc:
> raise exceptions.TimeoutError() from exc
E asyncio.exceptions.TimeoutError
C:\Miniconda3\envs\dask-distributed\lib\asyncio\tasks.py:492: TimeoutError
During handling of the above exception, another exception occurred:
async def async_fn():
result = None
with dask.config.set(config):
async with _cluster_factory() as (s, workers), _client_factory(
s
) as c:
args = [s] + workers
if c is not None:
args = [c] + args
try:
coro = func(*args, *outer_args, **kwargs)
task = asyncio.create_task(coro)
coro2 = utils_wait_for(
asyncio.shield(task), timeout=deadline.remaining
)
result = await coro2
validate_state(s, *workers)
except asyncio.TimeoutError:
assert task
elapsed = deadline.elapsed
buffer = io.StringIO()
# This stack indicates where the coro/test is suspended
task.print_stack(file=buffer)
if cluster_dump_directory:
await dump_cluster_state(
s=s,
ws=workers,
output_dir=cluster_dump_directory,
func_name=func.__name__,
)
task.cancel()
while not task.cancelled():
> await asyncio.sleep(0.01)
distributed\utils_test.py:1029:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
delay = 0.01, result = None
async def sleep(delay, result=None, *, loop=None):
"""Coroutine that completes after a given time (in seconds)."""
if loop is not None:
warnings.warn("The loop argument is deprecated since Python 3.8, "
"and scheduled for removal in Python 3.10.",
DeprecationWarning, stacklevel=2)
if delay <= 0:
await __sleep0()
return result
if loop is None:
loop = events.get_running_loop()
future = loop.create_future()
h = loop.call_later(delay,
futures._set_result_unless_cancelled,
future, result)
try:
> return await future
E asyncio.exceptions.CancelledError
C:\Miniconda3\envs\dask-distributed\lib\asyncio\tasks.py:652: CancelledError
During handling of the above exception, another exception occurred:
fut = <Task cancelled name='Task-203122' coro=<gen_cluster.<locals>._.<locals>.test_func.<locals>.async_fn() done, defined at D:\a\distributed\distributed\distributed\utils_test.py:994>>
timeout = 60
async def wait_for(fut, timeout, *, loop=None):
"""Wait for the single Future or coroutine to complete, with timeout.
Coroutine will be wrapped in Task.
Returns result of the Future or coroutine. When a timeout occurs,
it cancels the task and raises TimeoutError. To avoid the task
cancellation, wrap it in shield().
If the wait is cancelled, the task is also cancelled.
This function is a coroutine.
"""
if loop is None:
loop = events.get_running_loop()
else:
warnings.warn("The loop argument is deprecated since Python 3.8, "
"and scheduled for removal in Python 3.10.",
DeprecationWarning, stacklevel=2)
if timeout is None:
return await fut
if timeout <= 0:
fut = ensure_future(fut, loop=loop)
if fut.done():
return fut.result()
await _cancel_and_wait(fut, loop=loop)
try:
return fut.result()
except exceptions.CancelledError as exc:
raise exceptions.TimeoutError() from exc
waiter = loop.create_future()
timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
cb = functools.partial(_release_waiter, waiter)
fut = ensure_future(fut, loop=loop)
fut.add_done_callback(cb)
try:
# wait until the future completes or the timeout
try:
await waiter
except exceptions.CancelledError:
if fut.done():
return fut.result()
else:
fut.remove_done_callback(cb)
# We must ensure that the task is not running
# after wait_for() returns.
# See https://bugs.python.org/issue32751
await _cancel_and_wait(fut, loop=loop)
raise
if fut.done():
return fut.result()
else:
fut.remove_done_callback(cb)
# We must ensure that the task is not running
# after wait_for() returns.
# See https://bugs.python.org/issue32751
await _cancel_and_wait(fut, loop=loop)
# In case task cancellation failed with some
# exception, we should re-raise it
# See https://bugs.python.org/issue40607
try:
> return fut.result()
E asyncio.exceptions.CancelledError
C:\Miniconda3\envs\dask-distributed\lib\asyncio\tasks.py:490: CancelledError
The above exception was the direct cause of the following exception:
args = (), kwds = {}
@wraps(func)
def inner(*args, **kwds):
with self._recreate_cm():
> return func(*args, **kwds)
C:\Miniconda3\envs\dask-distributed\lib\contextlib.py:79:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
C:\Miniconda3\envs\dask-distributed\lib\contextlib.py:79: in inner
return func(*args, **kwds)
distributed\utils_test.py:1100: in test_func
return _run_and_close_tornado(async_fn_outer)
distributed\utils_test.py:378: in _run_and_close_tornado
return asyncio_run(inner_fn(), loop_factory=get_loop_factory())
distributed\compatibility.py:236: in asyncio_run
return loop.run_until_complete(main)
C:\Miniconda3\envs\dask-distributed\lib\asyncio\base_events.py:647: in run_until_complete
return future.result()
distributed\utils_test.py:375: in inner_fn
return await async_fn(*args, **kwargs)
distributed\utils_test.py:1097: in async_fn_outer
return await utils_wait_for(async_fn(), timeout=timeout * 2)
distributed\utils.py:1927: in wait_for
return await asyncio.wait_for(fut, timeout)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
fut = <Task cancelled name='Task-203122' coro=<gen_cluster.<locals>._.<locals>.test_func.<locals>.async_fn() done, defined at D:\a\distributed\distributed\distributed\utils_test.py:994>>
timeout = 60
async def wait_for(fut, timeout, *, loop=None):
"""Wait for the single Future or coroutine to complete, with timeout.
Coroutine will be wrapped in Task.
Returns result of the Future or coroutine. When a timeout occurs,
it cancels the task and raises TimeoutError. To avoid the task
cancellation, wrap it in shield().
If the wait is cancelled, the task is also cancelled.
This function is a coroutine.
"""
if loop is None:
loop = events.get_running_loop()
else:
warnings.warn("The loop argument is deprecated since Python 3.8, "
"and scheduled for removal in Python 3.10.",
DeprecationWarning, stacklevel=2)
if timeout is None:
return await fut
if timeout <= 0:
fut = ensure_future(fut, loop=loop)
if fut.done():
return fut.result()
await _cancel_and_wait(fut, loop=loop)
try:
return fut.result()
except exceptions.CancelledError as exc:
raise exceptions.TimeoutError() from exc
waiter = loop.create_future()
timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
cb = functools.partial(_release_waiter, waiter)
fut = ensure_future(fut, loop=loop)
fut.add_done_callback(cb)
try:
# wait until the future completes or the timeout
try:
await waiter
except exceptions.CancelledError:
if fut.done():
return fut.result()
else:
fut.remove_done_callback(cb)
# We must ensure that the task is not running
# after wait_for() returns.
# See https://bugs.python.org/issue32751
await _cancel_and_wait(fut, loop=loop)
raise
if fut.done():
return fut.result()
else:
fut.remove_done_callback(cb)
# We must ensure that the task is not running
# after wait_for() returns.
# See https://bugs.python.org/issue32751
await _cancel_and_wait(fut, loop=loop)
# In case task cancellation failed with some
# exception, we should re-raise it
# See https://bugs.python.org/issue40607
try:
return fut.result()
except exceptions.CancelledError as exc:
> raise exceptions.TimeoutError() from exc
E asyncio.exceptions.TimeoutError
C:\Miniconda3\envs\dask-distributed\lib\asyncio\tasks.py:492: TimeoutError
Check warning on line 0 in distributed.tests.test_asyncprocess
github-actions / Unit Test Results
1 out of 9 runs failed: test_simple (distributed.tests.test_asyncprocess)
artifacts/windows-latest-3.10-queue-notci1/pytest.xml [took 7s]
Raw output
assert 2.355825901031494 < 2.0
@nodebug
@gen_test()
async def test_simple():
to_child = get_mp_context().Queue()
from_child = get_mp_context().Queue()
proc = AsyncProcess(target=feed, args=(to_child, from_child))
assert not proc.is_alive()
assert proc.pid is None
assert proc.exitcode is None
assert not proc.daemon
proc.daemon = True
assert proc.daemon
wr1 = weakref.ref(proc)
wr2 = weakref.ref(proc._process)
# join() before start()
with pytest.raises(AssertionError):
await proc.join()
await proc.start()
assert proc.is_alive()
assert proc.pid is not None
assert proc.exitcode is None
t1 = time()
with pytest.raises(asyncio.TimeoutError):
await proc.join(timeout=0.02)
dt = time() - t1
assert 0.2 >= dt >= 0.001
assert proc.is_alive()
assert proc.pid is not None
assert proc.exitcode is None
# setting daemon attribute after start()
with pytest.raises(AssertionError):
proc.daemon = False
to_child.put(5)
assert from_child.get() == 5
# child should be stopping now
t1 = time()
await proc.join(timeout=30)
dt = time() - t1
assert dt <= 1.0
assert not proc.is_alive()
assert proc.pid is not None
assert proc.exitcode == 0
# join() again
t1 = time()
await proc.join()
dt = time() - t1
assert dt <= 0.6
del proc
start = time()
while wr1() is not None and time() < start + 1:
# Perhaps the GIL switched before _watch_process() exit,
# help it a little
sleep(0.001)
gc.collect()
if wr1() is not None:
# Help diagnosing
from types import FrameType
p = wr1()
if p is not None:
rc = sys.getrefcount(p)
refs = gc.get_referrers(p)
del p
print("refs to proc:", rc, refs)
frames = [r for r in refs if isinstance(r, FrameType)]
for i, f in enumerate(frames):
print(
"frames #%d:" % i,
f.f_code.co_name,
f.f_code.co_filename,
sorted(f.f_locals),
)
pytest.fail("AsyncProcess should have been destroyed")
t1 = time()
while wr2() is not None:
await asyncio.sleep(0.01)
gc.collect()
dt = time() - t1
> assert dt < 2.0
E assert 2.355825901031494 < 2.0
distributed\tests\test_asyncprocess.py:144: AssertionError
Check warning on line 0 in distributed.tests.test_pubsub
github-actions / Unit Test Results
1 out of 9 runs failed: test_client_worker (distributed.tests.test_pubsub)
artifacts/windows-latest-3.10-queue-notci1/pytest.xml [took 4s]
Raw output
assert 1690542609.8820581 < (1690542606.881374 + 3)
+ where 1690542609.8820581 = time()
c = <Client: No scheduler connected>
s = <Scheduler 'tcp://127.0.0.1:54133', workers: 0, cores: 0, tasks: 0>
a = <Worker 'tcp://127.0.0.1:54134', name: 0, status: closed, stored: 0, running: 0/1, ready: 0, comm: 0, waiting: 0>
b = <Worker 'tcp://127.0.0.1:54136', name: 1, status: closed, stored: 0, running: 0/2, ready: 0, comm: 0, waiting: 0>
@gen_cluster(client=True)
async def test_client_worker(c, s, a, b):
sub = Sub("a", client=c, worker=None)
def f(x):
pub = Pub("a")
pub.put(x)
futures = c.map(f, range(10))
await wait(futures)
L = []
for _ in range(10):
result = await sub.get()
L.append(result)
assert set(L) == set(range(10))
sps = s.extensions["pubsub"]
aps = a.extensions["pubsub"]
bps = b.extensions["pubsub"]
start = time()
while (
sps.publishers["a"]
or sps.subscribers["a"]
or aps.publishers["a"]
or bps.publishers["a"]
or len(sps.client_subscribers["a"]) != 1
):
await asyncio.sleep(0.01)
assert time() < start + 3
del sub
start = time()
while (
sps.client_subscribers
or any(aps.publish_to_scheduler.values())
or any(bps.publish_to_scheduler.values())
):
await asyncio.sleep(0.01)
> assert time() < start + 3
E assert 1690542609.8820581 < (1690542606.881374 + 3)
E + where 1690542609.8820581 = time()
distributed\tests\test_pubsub.py:118: AssertionError
Check warning on line 0 in distributed.tests.test_stress
github-actions / Unit Test Results
1 out of 9 runs failed: test_chaos_rechunk (distributed.tests.test_stress)
artifacts/windows-latest-3.10-queue-notci1/pytest.xml [took 1m 1s]
Raw output
asyncio.exceptions.TimeoutError
self = <Nanny: None, threads: 2>
async def start_unsafe(self):
"""Start nanny, start local process, start watching"""
await super().start_unsafe()
ports = parse_ports(self._start_port)
for port in ports:
start_address = address_from_user_args(
host=self._start_host,
port=port,
interface=self._interface,
protocol=self._protocol,
security=self.security,
)
try:
await self.listen(
start_address, **self.security.get_listen_args("worker")
)
except OSError as e:
if len(ports) > 1 and e.errno == errno.EADDRINUSE:
continue
else:
raise
else:
self._start_address = start_address
break
else:
raise ValueError(
f"Could not start Nanny on host {self._start_host} "
f"with port {self._start_port}"
)
self.ip = get_address_host(self.address)
for preload in self.preloads:
await preload.start()
msg = await self.scheduler.register_nanny()
for name, plugin in msg["nanny-plugins"].items():
await self.plugin_add(plugin=plugin, name=name)
logger.info(" Start Nanny at: %r", self.address)
> response = await self.instantiate()
distributed\nanny.py:360:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
distributed\nanny.py:420: in instantiate
result = await wait_for(self.process.start(), self.death_timeout)
distributed\utils.py:1927: in wait_for
return await asyncio.wait_for(fut, timeout)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
fut = <Task cancelled name='Task-420536' coro=<WorkerProcess.start() done, defined at D:\a\distributed\distributed\distributed\nanny.py:682>>
timeout = 15
async def wait_for(fut, timeout):
"""Wait for the single Future or coroutine to complete, with timeout.
Coroutine will be wrapped in Task.
Returns result of the Future or coroutine. When a timeout occurs,
it cancels the task and raises TimeoutError. To avoid the task
cancellation, wrap it in shield().
If the wait is cancelled, the task is also cancelled.
This function is a coroutine.
"""
loop = events.get_running_loop()
if timeout is None:
return await fut
if timeout <= 0:
fut = ensure_future(fut, loop=loop)
if fut.done():
return fut.result()
await _cancel_and_wait(fut, loop=loop)
try:
return fut.result()
except exceptions.CancelledError as exc:
raise exceptions.TimeoutError() from exc
waiter = loop.create_future()
timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
cb = functools.partial(_release_waiter, waiter)
fut = ensure_future(fut, loop=loop)
fut.add_done_callback(cb)
try:
# wait until the future completes or the timeout
try:
> await waiter
E asyncio.exceptions.CancelledError
C:\Miniconda3\envs\dask-distributed\lib\asyncio\tasks.py:432: CancelledError
During handling of the above exception, another exception occurred:
fut = <Task cancelled name='Task-420505' coro=<Nanny.start_unsafe() done, defined at D:\a\distributed\distributed\distributed\nanny.py:318>>
timeout = 15
async def wait_for(fut, timeout):
"""Wait for the single Future or coroutine to complete, with timeout.
Coroutine will be wrapped in Task.
Returns result of the Future or coroutine. When a timeout occurs,
it cancels the task and raises TimeoutError. To avoid the task
cancellation, wrap it in shield().
If the wait is cancelled, the task is also cancelled.
This function is a coroutine.
"""
loop = events.get_running_loop()
if timeout is None:
return await fut
if timeout <= 0:
fut = ensure_future(fut, loop=loop)
if fut.done():
return fut.result()
await _cancel_and_wait(fut, loop=loop)
try:
return fut.result()
except exceptions.CancelledError as exc:
raise exceptions.TimeoutError() from exc
waiter = loop.create_future()
timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
cb = functools.partial(_release_waiter, waiter)
fut = ensure_future(fut, loop=loop)
fut.add_done_callback(cb)
try:
# wait until the future completes or the timeout
try:
await waiter
except exceptions.CancelledError:
if fut.done():
return fut.result()
else:
fut.remove_done_callback(cb)
# We must ensure that the task is not running
# after wait_for() returns.
# See https://bugs.python.org/issue32751
await _cancel_and_wait(fut, loop=loop)
raise
if fut.done():
return fut.result()
else:
fut.remove_done_callback(cb)
# We must ensure that the task is not running
# after wait_for() returns.
# See https://bugs.python.org/issue32751
await _cancel_and_wait(fut, loop=loop)
# In case task cancellation failed with some
# exception, we should re-raise it
# See https://bugs.python.org/issue40607
try:
> return fut.result()
E asyncio.exceptions.CancelledError
C:\Miniconda3\envs\dask-distributed\lib\asyncio\tasks.py:456: CancelledError
The above exception was the direct cause of the following exception:
self = <Nanny: None, threads: 2>
@final
async def start(self):
async with self._startup_lock:
if self.status == Status.failed:
assert self.__startup_exc is not None
raise self.__startup_exc
elif self.status != Status.init:
return self
timeout = getattr(self, "death_timeout", None)
async def _close_on_failure(exc: Exception) -> None:
await self.close(reason=f"failure-to-start-{str(type(exc))}")
self.status = Status.failed
self.__startup_exc = exc
try:
> await wait_for(self.start_unsafe(), timeout=timeout)
distributed\core.py:626:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
distributed\utils.py:1927: in wait_for
return await asyncio.wait_for(fut, timeout)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
fut = <Task cancelled name='Task-420505' coro=<Nanny.start_unsafe() done, defined at D:\a\distributed\distributed\distributed\nanny.py:318>>
timeout = 15
async def wait_for(fut, timeout):
"""Wait for the single Future or coroutine to complete, with timeout.
Coroutine will be wrapped in Task.
Returns result of the Future or coroutine. When a timeout occurs,
it cancels the task and raises TimeoutError. To avoid the task
cancellation, wrap it in shield().
If the wait is cancelled, the task is also cancelled.
This function is a coroutine.
"""
loop = events.get_running_loop()
if timeout is None:
return await fut
if timeout <= 0:
fut = ensure_future(fut, loop=loop)
if fut.done():
return fut.result()
await _cancel_and_wait(fut, loop=loop)
try:
return fut.result()
except exceptions.CancelledError as exc:
raise exceptions.TimeoutError() from exc
waiter = loop.create_future()
timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
cb = functools.partial(_release_waiter, waiter)
fut = ensure_future(fut, loop=loop)
fut.add_done_callback(cb)
try:
# wait until the future completes or the timeout
try:
await waiter
except exceptions.CancelledError:
if fut.done():
return fut.result()
else:
fut.remove_done_callback(cb)
# We must ensure that the task is not running
# after wait_for() returns.
# See https://bugs.python.org/issue32751
await _cancel_and_wait(fut, loop=loop)
raise
if fut.done():
return fut.result()
else:
fut.remove_done_callback(cb)
# We must ensure that the task is not running
# after wait_for() returns.
# See https://bugs.python.org/issue32751
await _cancel_and_wait(fut, loop=loop)
# In case task cancellation failed with some
# exception, we should re-raise it
# See https://bugs.python.org/issue40607
try:
return fut.result()
except exceptions.CancelledError as exc:
> raise exceptions.TimeoutError() from exc
E asyncio.exceptions.TimeoutError
C:\Miniconda3\envs\dask-distributed\lib\asyncio\tasks.py:458: TimeoutError
During handling of the above exception, another exception occurred:
self = <Nanny: None, threads: 2>
@final
async def start(self):
async with self._startup_lock:
if self.status == Status.failed:
assert self.__startup_exc is not None
raise self.__startup_exc
elif self.status != Status.init:
return self
timeout = getattr(self, "death_timeout", None)
async def _close_on_failure(exc: Exception) -> None:
await self.close(reason=f"failure-to-start-{str(type(exc))}")
self.status = Status.failed
self.__startup_exc = exc
try:
await wait_for(self.start_unsafe(), timeout=timeout)
except asyncio.TimeoutError as exc:
> await _close_on_failure(exc)
distributed\core.py:628:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
distributed\nanny.py:599: in close
await self.kill(timeout=timeout, reason=reason)
distributed\nanny.py:382: in kill
await self.process.kill(reason=reason, timeout=0.8 * (deadline - time()))
distributed\nanny.py:818: in kill
await self.running.wait()
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
self = <asyncio.locks.Event object at 0x000001E55866C850 [unset]>
async def wait(self):
"""Block until the internal flag is true.
If the internal flag is true on entry, return True
immediately. Otherwise, block until another coroutine calls
set() to set the flag to true, then return True.
"""
if self._value:
return True
fut = self._get_loop().create_future()
self._waiters.append(fut)
try:
> await fut
E asyncio.exceptions.CancelledError
C:\Miniconda3\envs\dask-distributed\lib\asyncio\locks.py:214: CancelledError
During handling of the above exception, another exception occurred:
async def async_fn():
result = None
with dask.config.set(config):
> async with _cluster_factory() as (s, workers), _client_factory(
s
) as c:
distributed\utils_test.py:997:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
C:\Miniconda3\envs\dask-distributed\lib\contextlib.py:199: in __aenter__
return await anext(self.gen)
distributed\utils_test.py:965: in _cluster_factory
s, ws = await start_cluster(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
nthreads = [('', 2), ('', 2), ('', 2), ('', 2), ('', 2), ('', 2)]
scheduler_addr = '127.0.0.1', security = None
Worker = <class 'distributed.nanny.Nanny'>
scheduler_kwargs = {'dashboard': False, 'dashboard_address': ':0', 'transition_counter_max': 500000}
worker_kwargs = {'death_timeout': 15, 'memory_limit': 7515721728, 'transition_counter_max': 500000}
async def start_cluster(
nthreads: list[tuple[str, int] | tuple[str, int, dict]],
scheduler_addr: str,
security: Security | dict[str, Any] | None = None,
Worker: type[ServerNode] = Worker,
scheduler_kwargs: dict[str, Any] | None = None,
worker_kwargs: dict[str, Any] | None = None,
) -> tuple[Scheduler, list[ServerNode]]:
scheduler_kwargs = scheduler_kwargs or {}
worker_kwargs = worker_kwargs or {}
s = await Scheduler(
security=security,
port=0,
host=scheduler_addr,
**scheduler_kwargs,
)
workers = [
Worker(
s.address,
nthreads=ncore[1],
name=i,
security=security,
host=ncore[0],
**(
merge(worker_kwargs, ncore[2]) # type: ignore
if len(ncore) > 2
else worker_kwargs
),
)
for i, ncore in enumerate(nthreads)
]
> await asyncio.gather(*workers)
E asyncio.exceptions.CancelledError
distributed\utils_test.py:789: CancelledError
During handling of the above exception, another exception occurred:
fut = <Task cancelled name='Task-420494' coro=<gen_cluster.<locals>._.<locals>.test_func.<locals>.async_fn() done, defined at D:\a\distributed\distributed\distributed\utils_test.py:994>>
timeout = 60
async def wait_for(fut, timeout):
"""Wait for the single Future or coroutine to complete, with timeout.
Coroutine will be wrapped in Task.
Returns result of the Future or coroutine. When a timeout occurs,
it cancels the task and raises TimeoutError. To avoid the task
cancellation, wrap it in shield().
If the wait is cancelled, the task is also cancelled.
This function is a coroutine.
"""
loop = events.get_running_loop()
if timeout is None:
return await fut
if timeout <= 0:
fut = ensure_future(fut, loop=loop)
if fut.done():
return fut.result()
await _cancel_and_wait(fut, loop=loop)
try:
return fut.result()
except exceptions.CancelledError as exc:
raise exceptions.TimeoutError() from exc
waiter = loop.create_future()
timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
cb = functools.partial(_release_waiter, waiter)
fut = ensure_future(fut, loop=loop)
fut.add_done_callback(cb)
try:
# wait until the future completes or the timeout
try:
await waiter
except exceptions.CancelledError:
if fut.done():
return fut.result()
else:
fut.remove_done_callback(cb)
# We must ensure that the task is not running
# after wait_for() returns.
# See https://bugs.python.org/issue32751
await _cancel_and_wait(fut, loop=loop)
raise
if fut.done():
return fut.result()
else:
fut.remove_done_callback(cb)
# We must ensure that the task is not running
# after wait_for() returns.
# See https://bugs.python.org/issue32751
await _cancel_and_wait(fut, loop=loop)
# In case task cancellation failed with some
# exception, we should re-raise it
# See https://bugs.python.org/issue40607
try:
> return fut.result()
E asyncio.exceptions.CancelledError
C:\Miniconda3\envs\dask-distributed\lib\asyncio\tasks.py:456: CancelledError
The above exception was the direct cause of the following exception:
args = (), kwds = {}
@wraps(func)
def inner(*args, **kwds):
with self._recreate_cm():
> return func(*args, **kwds)
C:\Miniconda3\envs\dask-distributed\lib\contextlib.py:79:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
C:\Miniconda3\envs\dask-distributed\lib\contextlib.py:79: in inner
return func(*args, **kwds)
distributed\utils_test.py:1100: in test_func
return _run_and_close_tornado(async_fn_outer)
distributed\utils_test.py:378: in _run_and_close_tornado
return asyncio_run(inner_fn(), loop_factory=get_loop_factory())
distributed\compatibility.py:236: in asyncio_run
return loop.run_until_complete(main)
C:\Miniconda3\envs\dask-distributed\lib\asyncio\base_events.py:649: in run_until_complete
return future.result()
distributed\utils_test.py:375: in inner_fn
return await async_fn(*args, **kwargs)
distributed\utils_test.py:1097: in async_fn_outer
return await utils_wait_for(async_fn(), timeout=timeout * 2)
distributed\utils.py:1927: in wait_for
return await asyncio.wait_for(fut, timeout)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
fut = <Task cancelled name='Task-420494' coro=<gen_cluster.<locals>._.<locals>.test_func.<locals>.async_fn() done, defined at D:\a\distributed\distributed\distributed\utils_test.py:994>>
timeout = 60
async def wait_for(fut, timeout):
"""Wait for the single Future or coroutine to complete, with timeout.
Coroutine will be wrapped in Task.
Returns result of the Future or coroutine. When a timeout occurs,
it cancels the task and raises TimeoutError. To avoid the task
cancellation, wrap it in shield().
If the wait is cancelled, the task is also cancelled.
This function is a coroutine.
"""
loop = events.get_running_loop()
if timeout is None:
return await fut
if timeout <= 0:
fut = ensure_future(fut, loop=loop)
if fut.done():
return fut.result()
await _cancel_and_wait(fut, loop=loop)
try:
return fut.result()
except exceptions.CancelledError as exc:
raise exceptions.TimeoutError() from exc
waiter = loop.create_future()
timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
cb = functools.partial(_release_waiter, waiter)
fut = ensure_future(fut, loop=loop)
fut.add_done_callback(cb)
try:
# wait until the future completes or the timeout
try:
await waiter
except exceptions.CancelledError:
if fut.done():
return fut.result()
else:
fut.remove_done_callback(cb)
# We must ensure that the task is not running
# after wait_for() returns.
# See https://bugs.python.org/issue32751
await _cancel_and_wait(fut, loop=loop)
raise
if fut.done():
return fut.result()
else:
fut.remove_done_callback(cb)
# We must ensure that the task is not running
# after wait_for() returns.
# See https://bugs.python.org/issue32751
await _cancel_and_wait(fut, loop=loop)
# In case task cancellation failed with some
# exception, we should re-raise it
# See https://bugs.python.org/issue40607
try:
return fut.result()
except exceptions.CancelledError as exc:
> raise exceptions.TimeoutError() from exc
E asyncio.exceptions.TimeoutError
C:\Miniconda3\envs\dask-distributed\lib\asyncio\tasks.py:458: TimeoutError
Check notice on line 0 in .github
github-actions / Unit Test Results
106 skipped tests found
There are 106 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.comm.tests.test_comms ‑ test_comm_closed_on_read_error[asyncio]
distributed.comm.tests.test_comms ‑ test_comm_closed_on_write_error[asyncio-BufferError]
distributed.comm.tests.test_comms ‑ test_comm_closed_on_write_error[asyncio-CustomBase]
distributed.comm.tests.test_comms ‑ test_comm_failure_threading[asyncio]
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_adaptive ‑ test_adaptive_scale_down_override
distributed.deploy.tests.test_old_ssh
distributed.deploy.tests.test_ssh
distributed.diagnostics.tests.test_memory_sampler ‑ test_pandas[False]
distributed.diagnostics.tests.test_memory_sampler ‑ test_pandas[True]
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_progress_stream
distributed.diagnostics.tests.test_rmm_diagnostics
distributed.diagnostics.tests.test_widgets
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_rechunk ‑ test_rechunk_avoid_needless_chunking
distributed.shuffle.tests.test_shuffle
distributed.shuffle.tests.test_shuffle ‑ test_minimal_version
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_computation_object_code_not_available
distributed.tests.test_client ‑ test_contiguous_load
distributed.tests.test_client ‑ test_dont_delete_recomputed_results
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_client ‑ test_nested_prioritization
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_jupyter
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_perf ‑ test_gc_diagnosis_rss_win
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
github-actions / Unit Test Results
3741 tests found (test 1 to 870)
There are 3741 tests, see "Raw output" for the list of tests 1 to 870.
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_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[asyncio]
distributed.comm.tests.test_comms ‑ test_comm_closed_on_read_error[tornado]
distributed.comm.tests.test_comms ‑ test_comm_closed_on_write_error[asyncio-BufferError]
distributed.comm.tests.test_comms ‑ test_comm_closed_on_write_error[asyncio-CustomBase]
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[asyncio]
distributed.comm.tests.test_comms ‑ test_comm_failure_threading[tornado]
distributed.comm.tests.test_comms ‑ test_default_client_server_ipv4[asyncio]
distributed.comm.tests.test_comms ‑ test_default_client_server_ipv4[tornado]
distributed.comm.tests.test_comms ‑ test_default_client_server_ipv6[asyncio]
distributed.comm.tests.test_comms ‑ test_default_client_server_ipv6[tornado]
distributed.comm.tests.test_comms ‑ test_get_address_host[asyncio]
distributed.comm.tests.test_comms ‑ test_get_address_host[tornado]
distributed.comm.tests.test_comms ‑ test_get_local_address_for[asyncio]
distributed.comm.tests.test_comms ‑ test_get_local_address_for[tornado]
distributed.comm.tests.test_comms ‑ test_handshake_slow_comm[asyncio]
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[asyncio]
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[asyncio]
distributed.comm.tests.test_comms ‑ test_resolve_address[tornado]
distributed.comm.tests.test_comms ‑ test_retry_connect[asyncio]
distributed.comm.tests.test_comms ‑ test_retry_connect[tornado]
distributed.comm.tests.test_comms ‑ test_tcp_adresses[asyncio]
distributed.comm.tests.test_comms ‑ test_tcp_adresses[tornado]
distributed.comm.tests.test_comms ‑ test_tcp_client_server_ipv4[asyncio]
distributed.comm.tests.test_comms ‑ test_tcp_client_server_ipv4[tornado]
distributed.comm.tests.test_comms ‑ test_tcp_client_server_ipv6[asyncio]
distributed.comm.tests.test_comms ‑ test_tcp_client_server_ipv6[tornado]
distributed.comm.tests.test_comms ‑ test_tcp_comm_closed_explicit[asyncio]
distributed.comm.tests.test_comms ‑ test_tcp_comm_closed_explicit[tornado]
distributed.comm.tests.test_comms ‑ test_tcp_comm_closed_implicit[asyncio]
distributed.comm.tests.test_comms ‑ test_tcp_comm_closed_implicit[tornado]
distributed.comm.tests.test_comms ‑ test_tcp_connect_timeout[asyncio]
distributed.comm.tests.test_comms ‑ test_tcp_connect_timeout[tornado]
distributed.comm.tests.test_comms ‑ test_tcp_deserialize[asyncio]
distributed.comm.tests.test_comms ‑ test_tcp_deserialize[tornado]
distributed.comm.tests.test_comms ‑ test_tcp_deserialize_eoferror[asyncio]
distributed.comm.tests.test_comms ‑ test_tcp_deserialize_eoferror[tornado]
distributed.comm.tests.test_comms ‑ test_tcp_deserialize_roundtrip[asyncio]
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[asyncio]
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[asyncio]
distributed.comm.tests.test_comms ‑ test_tcp_many_listeners[tornado]
distributed.comm.tests.test_comms ‑ test_tcp_repr[asyncio]
distributed.comm.tests.test_comms ‑ test_tcp_repr[tornado]
distributed.comm.tests.test_comms ‑ test_tcp_specific[asyncio]
distributed.comm.tests.test_comms ‑ test_tcp_specific[tornado]
distributed.comm.tests.test_comms ‑ test_tls_adresses[asyncio]
distributed.comm.tests.test_comms ‑ test_tls_adresses[tornado]
distributed.comm.tests.test_comms ‑ test_tls_client_server_ipv4[asyncio]
distributed.comm.tests.test_comms ‑ test_tls_client_server_ipv4[tornado]
distributed.comm.tests.test_comms ‑ test_tls_client_server_ipv6[asyncio]
distributed.comm.tests.test_comms ‑ test_tls_client_server_ipv6[tornado]
distributed.comm.tests.test_comms ‑ test_tls_comm_closed_explicit[asyncio]
distributed.comm.tests.test_comms ‑ test_tls_comm_closed_explicit[tornado]
distributed.comm.tests.test_comms ‑ test_tls_comm_closed_implicit[asyncio]
distributed.comm.tests.test_comms ‑ test_tls_comm_closed_implicit[tornado]
distributed.comm.tests.test_comms ‑ test_tls_reject_certificate[asyncio]
distributed.comm.tests.test_comms ‑ test_tls_reject_certificate[tornado]
distributed.comm.tests.test_comms ‑ test_tls_repr[asyncio]
distributed.comm.tests.test_comms ‑ test_tls_repr[tornado]
distributed.comm.tests.test_comms ‑ test_tls_specific[asyncio-None]
distributed.comm.tests.test_comms ‑ test_tls_specific[asyncio-localhost]
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[asyncio]
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_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_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_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_cores_memory
distributed.deploy.tests.test_adaptive ‑ test_adapt_down
distributed.deploy.tests.test_adaptive ‑ test_adapt_quickly
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_no_memory_limit
distributed.deploy.tests.test_adaptive ‑ test_adaptive_scale_down_override
distributed.deploy.tests.test_adaptive ‑ test_adaptive_stopped
distributed.deploy.tests.test_adaptive ‑ test_avoid_churn
distributed.deploy.tests.test_adaptive ‑ test_basic_no_loop
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_scale_needs_to_be_awaited
distributed.deploy.tests.test_adaptive ‑ test_target_duration
distributed.deploy.tests.test_adaptive ‑ test_update_adaptive
distributed.deploy.tests.test_adaptive ‑ test_worker_keys
distributed.deploy.tests.test_adaptive_core ‑ test_adapt_oserror_safe_target
distributed.deploy.tests.test_adaptive_core ‑ test_adapt_oserror_scale
distributed.deploy.tests.test_adaptive_core ‑ test_adapt_stop_del
distributed.deploy.tests.test_adaptive_core ‑ test_interval
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_logs_deprecated
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_logs
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.diagnostics.tests.test_cluster_dump_plugin ‑ test_cluster_dump_plugin
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_memory_sampler ‑ test_async
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_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_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_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_log_event_plugin
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_register_plugin_on_scheduler
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_register_scheduler_plugin
distributed.diagnostics.tests.test_scheduler_plugin ‑ test_register_scheduler_plugin_pickle_disabled
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_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_widgets
distributed.diagnostics.tests.test_widgets ‑ test_fast
distributed.diagnostics.tests.test_widgets ‑ test_multi_progressbar_widget
distributed.diagnostics.tests.test_widgets ‑ test_multibar_complete
distributed.diagnostics.tests.test_widgets ‑ test_multibar_func_warns
distributed.diagnostics.tests.test_widgets ‑ test_multibar_with_spans
distributed.diagnostics.tests.test_widgets ‑ test_progressbar_cancel
distributed.diagnostics.tests.test_widgets ‑ test_progressbar_done
distributed.diagnostics.tests.test_widgets ‑ test_progressbar_widget
distributed.diagnostics.tests.test_widgets ‑ test_serializers
distributed.diagnostics.tests.test_widgets ‑ test_tls
distributed.diagnostics.tests.test_widgets ‑ test_values
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_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_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.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_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_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_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_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[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]
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_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_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_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_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.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]
Check notice on line 0 in .github
github-actions / Unit Test Results
3741 tests found (test 871 to 1747)
There are 3741 tests, see "Raw output" for the list of tests 871 to 1747.
Raw output
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_deser_memoryview[data_in0]
distributed.protocol.tests.test_serialize ‑ test_deser_memoryview[data_in1]
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_profile_nested_sizeof
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_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.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_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_statistics
distributed.shuffle.tests.test_merge
distributed.shuffle.tests.test_merge ‑ test_basic_merge[all-inner]
distributed.shuffle.tests.test_merge ‑ test_basic_merge[all-left]
distributed.shuffle.tests.test_merge ‑ test_basic_merge[all-outer]
distributed.shuffle.tests.test_merge ‑ test_basic_merge[all-right]
distributed.shuffle.tests.test_merge ‑ test_basic_merge[none-inner]
distributed.shuffle.tests.test_merge ‑ test_basic_merge[none-left]
distributed.shuffle.tests.test_merge ‑ test_basic_merge[none-outer]
distributed.shuffle.tests.test_merge ‑ test_basic_merge[none-right]
distributed.shuffle.tests.test_merge ‑ test_basic_merge[some-inner]
distributed.shuffle.tests.test_merge ‑ test_basic_merge[some-left]
distributed.shuffle.tests.test_merge ‑ test_basic_merge[some-outer]
distributed.shuffle.tests.test_merge ‑ test_basic_merge[some-right]
distributed.shuffle.tests.test_merge ‑ test_merge[all-inner]
distributed.shuffle.tests.test_merge ‑ test_merge[all-left]
distributed.shuffle.tests.test_merge ‑ test_merge[all-outer]
distributed.shuffle.tests.test_merge ‑ test_merge[all-right]
distributed.shuffle.tests.test_merge ‑ test_merge[none-inner]
distributed.shuffle.tests.test_merge ‑ test_merge[none-left]
distributed.shuffle.tests.test_merge ‑ test_merge[none-outer]
distributed.shuffle.tests.test_merge ‑ test_merge[none-right]
distributed.shuffle.tests.test_merge ‑ test_merge[some-inner]
distributed.shuffle.tests.test_merge ‑ test_merge[some-left]
distributed.shuffle.tests.test_merge ‑ test_merge[some-outer]
distributed.shuffle.tests.test_merge ‑ test_merge[some-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_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_rechunk
distributed.shuffle.tests.test_rechunk ‑ test_dtype
distributed.shuffle.tests.test_rechunk ‑ test_lowlevel_rechunk[False-10]
distributed.shuffle.tests.test_rechunk ‑ test_lowlevel_rechunk[False-1]
distributed.shuffle.tests.test_rechunk ‑ test_lowlevel_rechunk[True-10]
distributed.shuffle.tests.test_rechunk ‑ test_lowlevel_rechunk[True-1]
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_0d
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_2d
distributed.shuffle.tests.test_rechunk ‑ test_rechunk_4d
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_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_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_single_output_chunk_raises
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_basic_integration[all-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_integration[all-20]
distributed.shuffle.tests.test_shuffle ‑ test_basic_integration[all-None]
distributed.shuffle.tests.test_shuffle ‑ test_basic_integration[none-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_integration[none-20]
distributed.shuffle.tests.test_shuffle ‑ test_basic_integration[none-None]
distributed.shuffle.tests.test_shuffle ‑ test_basic_integration[some-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_integration[some-20]
distributed.shuffle.tests.test_shuffle ‑ test_basic_integration[some-None]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-1-1-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-1-1-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-1-10-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-1-10-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-1-2-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-1-2-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-20-1-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-20-1-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-20-10-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-20-10-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-20-2-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[False-20-2-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-1-1-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-1-1-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-1-10-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-1-10-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-1-2-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-1-2-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-20-1-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-20-1-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-20-10-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-20-10-1]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[True-20-2-10]
distributed.shuffle.tests.test_shuffle ‑ test_basic_lowlevel_shuffle[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[all]
distributed.shuffle.tests.test_shuffle ‑ test_concurrent[none]
distributed.shuffle.tests.test_shuffle ‑ test_concurrent[some]
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_error_offload
distributed.shuffle.tests.test_shuffle ‑ test_error_receive
distributed.shuffle.tests.test_shuffle ‑ test_error_send
distributed.shuffle.tests.test_shuffle ‑ test_get_or_create_from_dangling_transfer
distributed.shuffle.tests.test_shuffle ‑ test_handle_null_partitions_p2p_shuffling
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_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
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_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_p2p
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_with_array_conversion[all-1]
distributed.shuffle.tests.test_shuffle ‑ test_shuffle_with_array_conversion[all-20]
distributed.shuffle.tests.test_shuffle ‑ test_shuffle_with_array_conversion[all-None]
distributed.shuffle.tests.test_shuffle ‑ test_shuffle_with_array_conversion[none-1]
distributed.shuffle.tests.test_shuffle ‑ test_shuffle_with_array_conversion[none-20]
distributed.shuffle.tests.test_shuffle ‑ test_shuffle_with_array_conversion[none-None]
distributed.shuffle.tests.test_shuffle ‑ test_shuffle_with_array_conversion[some-1]
distributed.shuffle.tests.test_shuffle ‑ test_shuffle_with_array_conversion[some-20]
distributed.shuffle.tests.test_shuffle ‑ test_shuffle_with_array_conversion[some-None]
distributed.shuffle.tests.test_shuffle ‑ test_split_by_worker
distributed.shuffle.tests.test_shuffle ‑ test_tail
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.shuffle.tests.test_shuffle_plugins ‑ test_split_by_partition
distributed.shuffle.tests.test_shuffle_plugins ‑ test_split_by_worker
distributed.shuffle.tests.test_shuffle_plugins ‑ test_split_by_worker_empty
distributed.shuffle.tests.test_shuffle_plugins ‑ test_split_by_worker_many_workers
distributed.tests.test_active_memory_manager ‑ test_ReduceReplicas
distributed.tests.test_active_memory_manager ‑ test_ReduceReplicas_stress
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_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
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_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[False-cancelled]
distributed.tests.test_cancelled_state ‑ test_deadlock_cancelled_after_inflight_before_gather_from_worker[False-resumed]
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-deserialize_task]
distributed.tests.test_cancelled_state ‑ test_execute_preamble_early_cancel[executing-False-execute]
distributed.tests.test_cancelled_state ‑ test_execute_preamble_early_cancel[executing-True-deserialize_task]
distributed.tests.test_cancelled_state ‑ test_execute_preamble_early_cancel[executing-True-execute]
distributed.tests.test_cancelled_state ‑ test_execute_preamble_early_cancel[resumed-False-deserialize_task]
distributed.tests.test_cancelled_state ‑ test_execute_preamble_early_cancel[resumed-False-execute]
distributed.tests.test_cancelled_state ‑ test_execute_preamble_early_cancel[resumed-True-deserialize_task]
distributed.tests.test_cancelled_state ‑ test_execute_preamble_early_cancel[resumed-True-execute]
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__persist
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_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_connectionpool_semaphore_loop
distributed.tests.test_client ‑ test_client_doesnt_close_given_loop
distributed.tests.test_client ‑ test_client_gather_semaphore_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_delete_recomputed_results
distributed.tests.test_client ‑ test_dont_hold_on_to_large_messages
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_events_all_servers_use_same_channel
distributed.tests.test_client ‑ test_events_subscribe_topic
distributed.tests.test_client ‑ test_events_subscribe_topic_cancelled
distributed.tests.test_client ‑ test_events_unsubscribe_raises_if_unknown
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_auto_inform
distributed.tests.test_client ‑ test_future_defaults_to_default_client
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_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_log_event
distributed.tests.test_client ‑ test_log_event_msgpack
distributed.tests.test_client ‑ test_log_event_multiple_clients
distributed.tests.test_client ‑ test_log_event_warn
distributed.tests.test_client ‑ test_log_event_warn_dask_warns
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_get
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
Check notice on line 0 in .github
github-actions / Unit Test Results
3741 tests found (test 1748 to 2709)
There are 3741 tests, see "Raw output" for the list of tests 1748 to 2709.
Raw output
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_raises_on_explicit_missing_data
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_array
distributed.tests.test_client ‑ test_recreate_error_collection
distributed.tests.test_client ‑ test_recreate_error_delayed
distributed.tests.test_client ‑ test_recreate_error_futures
distributed.tests.test_client ‑ test_recreate_error_not_error
distributed.tests.test_client ‑ test_recreate_error_sync
distributed.tests.test_client ‑ test_recreate_task_array
distributed.tests.test_client ‑ test_recreate_task_collection
distributed.tests.test_client ‑ test_recreate_task_delayed
distributed.tests.test_client ‑ test_recreate_task_futures
distributed.tests.test_client ‑ test_recreate_task_sync
distributed.tests.test_client ‑ test_register_worker_plugin_exception
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[False]
distributed.tests.test_client ‑ test_restart_workers_exception[True]
distributed.tests.test_client ‑ test_restart_workers_no_nanny_raises
distributed.tests.test_client ‑ test_restart_workers_timeout[False]
distributed.tests.test_client ‑ test_restart_workers_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_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_serialize_future
distributed.tests.test_client ‑ test_serialize_future_without_client
distributed.tests.test_client ‑ test_set_as_default
distributed.tests.test_client ‑ test_short_tracebacks
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_no_default
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_when_submitting_large_values
distributed.tests.test_client ‑ test_weight_occupancy_against_data_movement
distributed.tests.test_client ‑ test_worker_aliases
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_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_async_task_group_call_later_executes_delayed_task_in_background
distributed.tests.test_core ‑ test_async_task_group_call_soon_executes_task_in_background
distributed.tests.test_core ‑ test_async_task_group_close_closes
distributed.tests.test_core ‑ test_async_task_group_close_does_not_cancel_existing_tasks
distributed.tests.test_core ‑ test_async_task_group_close_prohibits_new_tasks
distributed.tests.test_core ‑ test_async_task_group_initialization
distributed.tests.test_core ‑ test_async_task_group_stop_cancels_long_running
distributed.tests.test_core ‑ test_async_task_group_stop_disallows_shutdown
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_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_ports
distributed.tests.test_core ‑ test_remove_cancels_connect_attempts
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_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_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_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]
distributed.tests.test_failed_workers ‑ test_submit_after_failed_worker_async[True]
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_who_has_clears_after_failed_connection
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_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_serializable
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_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_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_log_event
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_port_range
distributed.tests.test_nanny ‑ test_nanny_process_failure
distributed.tests.test_nanny ‑ test_nanny_timeout
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_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
distributed.tests.test_preload ‑ test_preload_import_time
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]
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_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_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_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_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_client_desires_keys_creates_ts
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_config_no_stealing
distributed.tests.test_scheduler ‑ test_config_stealing
distributed.tests.test_scheduler ‑ test_configurable_events_log_length
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_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_dumps_task
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_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_removed
distributed.tests.test_scheduler ‑ test_gather_failing_cnn_error
distributed.tests.test_scheduler ‑ test_gather_failing_cnn_recover
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_idempotent_plugins
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]
Check notice on line 0 in .github
github-actions / Unit Test Results
3741 tests found (test 2710 to 3651)
There are 3741 tests, see "Raw output" for the list of tests 2710 to 3651.
Raw output
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_non_idempotent_plugins
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_remove_worker_by_name_from_scheduler
distributed.tests.test_scheduler ‑ test_remove_worker_from_scheduler
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_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_close
distributed.tests.test_scheduler ‑ test_retire_workers_empty
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_run_on_scheduler
distributed.tests.test_scheduler ‑ test_run_on_scheduler_disabled
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_story
distributed.tests.test_scheduler ‑ test_submit_dependency_of_erred_task
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
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_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_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_close_sync
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_client_desires_keys_creates_tg
distributed.tests.test_spans ‑ test_client_desires_keys_creates_ts
distributed.tests.test_spans ‑ test_code
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_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_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_no_kwargs
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_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_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_deserialize_for_cli_deprecated
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_bytes_deprecated
distributed.tests.test_utils ‑ test_format_dashboard_link
distributed.tests.test_utils ‑ test_format_time_deprecated
distributed.tests.test_utils ‑ test_funcname_deprecated
distributed.tests.test_utils ‑ test_get_ip_interface
distributed.tests.test_utils ‑ test_get_mp_context
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_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_maybe_complex
distributed.tests.test_utils ‑ test_nbytes
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_bytes_deprecated
distributed.tests.test_utils ‑ test_parse_ports
distributed.tests.test_utils ‑ test_parse_timedelta_deprecated
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_serialize_for_cli_deprecated
distributed.tests.test_utils ‑ test_set_thread_state
distributed.tests.test_utils ‑ test_sync_closed_loop
distributed.tests.test_utils ‑ test_sync_error
distributed.tests.test_utils ‑ test_sync_timeout
distributed.tests.test_utils ‑ test_tmpfile_deprecated
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_typename_deprecated
distributed.tests.test_utils ‑ test_warn_on_duration
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_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_perf ‑ test_fractional_timer
distributed.tests.test_utils_perf ‑ test_gc_diagnosis_cpu_time
distributed.tests.test_utils_perf ‑ test_gc_diagnosis_rss_win
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_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_dump_cluster_state
distributed.tests.test_utils_test ‑ test_dump_cluster_state_nannies
distributed.tests.test_utils_test ‑ test_dump_cluster_state_no_workers
distributed.tests.test_utils_test ‑ test_dump_cluster_state_timeout
distributed.tests.test_utils_test ‑ test_dump_cluster_state_unresponsive_local_worker
distributed.tests.test_utils_test ‑ test_dump_cluster_unresponsive_remote_worker
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_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_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_conda_install
distributed.tests.test_worker ‑ test_conda_install_fails_on_returncode
distributed.tests.test_worker ‑ test_conda_install_fails_when_conda_not_found
distributed.tests.test_worker ‑ test_conda_install_fails_when_conda_raises
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_error
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[True]
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_gpu_executor
distributed.tests.test_worker ‑ test_heartbeat_comm_closed
distributed.tests.test_worker ‑ test_heartbeat_missing
distributed.tests.test_worker ‑ test_heartbeat_missing_real_cluster
distributed.tests.test_worker ‑ test_heartbeat_missing_restarts
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_event
distributed.tests.test_worker ‑ test_log_exception_on_failed_task
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_package_install_failing_does_not_restart_on_nanny
distributed.tests.test_worker ‑ test_package_install_installs_once_with_multiple_workers
distributed.tests.test_worker ‑ test_package_install_restarts_on_nanny
distributed.tests.test_worker ‑ test_pid
distributed.tests.test_worker ‑ test_pip_install
distributed.tests.test_worker ‑ test_pip_install_fails
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_steal_during_task_deserialization
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_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_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_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_run_spec_deserialization
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
Check notice on line 0 in .github
github-actions / Unit Test Results
3741 tests found (test 3652 to 3741)
There are 3741 tests, see "Raw output" for the list of tests 3652 to 3741.
Raw output
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]
Loading