Python Client.close方法代码示例

# 需要导入模块: from dask.distributed import Client [as 别名]
# 或者: from dask.distributed.Client import close [as 别名]
def test_error():
    with scheduler_and_workers() as (s, (a, b)):
        c = Client(s.address_to_clients)

        assert raises(TypeError,
                lambda: c.get({'x': 1, 'y': (inc, 'x', 'x')}, 'y'))
        assert 'y' not in s.data
        c.close()

# 需要导入模块: from dask.distributed import Client [as 别名]
# 或者: from dask.distributed.Client import close [as 别名]
def test_get_with_dill():
    with scheduler_and_workers() as (s, (a, b)):
        c = Client(s.address_to_clients)

        dsk = {'x': 1, 'y': (partial(add, 1), 'x')}
        keys = 'y'

        assert c.get(dsk, keys) == 2
        c.close()

# 需要导入模块: from dask.distributed import Client [as 别名]
# 或者: from dask.distributed.Client import close [as 别名]
def test_get():
    with scheduler_and_workers() as (s, (a, b)):
        c = Client(s.address_to_clients)

        dsk = {'x': 1, 'y': (add, 'x', 'x'), 'z': (inc, 'y')}
        keys = ['y', 'z']

        assert c.get(dsk, keys) == [2, 3]
        c.close()

# 需要导入模块: from dask.distributed import Client [as 别名]
# 或者: from dask.distributed.Client import close [as 别名]
def test_multiple_clients():
    with scheduler_and_workers(1) as (s, (a,)):
        c = Client(s.address_to_clients)
        d = Client(s.address_to_clients)

        assert c.get({'x': (inc, 1)}, 'x') == d.get({'x': (inc, 1)}, 'x')

        pool = ThreadPool(2)

        future1 = pool.apply_async(c.get,
                                   args=({'x': 1, 'y': (inc, 'x')}, 'y'))
        future2 = pool.apply_async(d.get,
                                   args=({'a': 1, 'b': (inc, 'a')}, 'b'))

        while not (future1.ready() and future2.ready()):
            sleep(1e-6)

        assert future1.get() == future2.get()
        c.close()
        d.close()

# 需要导入模块: from dask.distributed import Client [as 别名]
# 或者: from dask.distributed.Client import close [as 别名]
def test_multiple_clients():
    with scheduler_and_workers(1) as (s, (a,)):
        c = Client(s.address_to_clients)
        d = Client(s.address_to_clients)

        assert c.get({'x': (inc, 1)}, 'x') == d.get({'x': (inc, 1)}, 'x')

        def sleep_inc(x):
            sleep(0.5)
            return x + 1

        pool = ThreadPool(2)

        future1 = pool.apply_async(c.get,
                                   args=({'x': 1, 'y': (sleep_inc, 'x')}, 'y'))
        future2 = pool.apply_async(d.get,
                                   args=({'a': 1, 'b': (sleep_inc, 'a')}, 'b'))

        assert future1.get() == future2.get()
        c.close()
        d.close()

# 需要导入模块: from dask.distributed import Client [as 别名]
# 或者: from dask.distributed.Client import close [as 别名]
def test_register_collections():
    try:
        import dask.bag as db
    except ImportError:
        return
    with scheduler_and_workers() as (s, (a, b)):
        c = Client(s.address_to_clients)

        b = db.from_sequence(range(5), npartitions=2).map(inc)
        assert not s.collections
        c.set_collection('mybag', b)
        assert 'mybag' in s.collections

        d = Client(s.address_to_clients)
        b2 = d.get_collection('mybag')

        assert (type(b) == type(b2) and
                b.npartitions == b2.npartitions)
        assert list(b) == list(b2)

        c.close()
        d.close()

# 需要导入模块: from dask.distributed import Client [as 别名]
# 或者: from dask.distributed.Client import close [as 别名]
            args.bin_width, args.filter_bandwidth, args.theta, args.shift
    ):
        start_time = datetime.now()
        ds = xr.open_mfdataset(
            ['/scratch/pkittiwi/fg1p/binned_noise_map/bin{:.2f}MHz/'
             'fbw{:.2f}MHz/theta{:.1f}/shift{:d}/binned_noise_map_bin{:.2f}MHz_'
             'fbw{:.2f}MHz_theta{:.1f}_shift{:d}_{:03d}.nc'
             .format(bw, fbw, t, s, bw, fbw, t, s, i) for i in range(500)],
            concat_dim=noise_dim, chunks=chunks
        )
        ds_masked = ds.where(mask == 1)
        noise_var = ds_masked.var(dim=['x', 'y']).compute()
        da = noise_var.to_array().squeeze()
        del da['variable']
        da.attrs['bin_width'] = bw
        da.attrs['filter_bandwidth'] = fbw
        da.attrs['theta'] = t
        da.attrs['shift'] = s
        da.name = 'binned_noise_variance'
        output_file = '/scratch/pkittiwi/fg1p/binned_noise_variance/' \
                      'binned_noise_variance_bin{:.2f}MHz_fbw{:.2f}MHz_' \
                      'theta{:.1f}_shift{:d}.nc'.format(bw, fbw, t, s)
        da.to_netcdf(output_file)
        print(
            'Finish {:s}. Spent {:.5f} sec on this file'
            .format(output_file, (datetime.now() - start_time).total_seconds())
        )

    client.close()
    cluster.close()

# 需要导入模块: from dask.distributed import Client [as 别名]
# 或者: from dask.distributed.Client import close [as 别名]
def test_status():
    with scheduler_and_workers() as (s, (a, b)):
        c = Client(s.address_to_clients)

        assert c.scheduler_status() == 'OK'
        c.close()