def get_dataset(self, key, info):
        """Load a dataset."""
        if self._channel != key.name:
            return

        logger.debug('Reading %s.', key.name)
        # FIXME: get this from MTD_MSIL1C.xml
        quantification_value = 10000.
        jp2 = glymur.Jp2k(self.filename)
        bitdepth = 0
        for seg in jp2.codestream.segment:
            try:
                bitdepth = max(bitdepth, seg.bitdepth[0])
            except AttributeError:
                pass

        jp2.dtype = (np.uint8 if bitdepth <= 8 else np.uint16)

        # Initialize the jp2 reader / doesn't work in a multi-threaded context.
        # jp2[0, 0]
        # data = da.from_array(jp2, chunks=CHUNK_SIZE) / quantification_value * 100

        data = da.from_delayed(delayed(jp2.read)(), jp2.shape, jp2.dtype)
        data = data.rechunk(CHUNK_SIZE) / quantification_value * 100

        proj = DataArray(data, dims=['y', 'x'])
        proj.attrs = info.copy()
        proj.attrs['units'] = '%'
        proj.attrs['platform_name'] = self.platform_name
        return proj

 def test_default_title(self):
     a = DataArray(easy_array((4, 3, 2)), dims=['a', 'b', 'c'])
     a.coords['c'] = [0, 1]
     a.coords['d'] = u'foo'
     self.plotfunc(a.isel(c=1))
     title = plt.gca().get_title()
     self.assertTrue('c = 1, d = foo' == title or 'd = foo, c = 1' == title)

    def read(self):
        """

        :return: DataArray objects populated with data read from eeg files. The size of the output is
        number of channels x number of start offsets x number of time series points
        The corresponding DataArray axes are: 'channels', 'start_offsets', 'offsets'

        """

        eventdata, read_ok_mask = self.read_file(self.dataroot,self.channels,self.start_offsets,self.read_size)
        # multiply by the gain
        eventdata *= self.params_dict['gain']

        eventdata = DataArray(eventdata,
                              dims=[self.channel_name, 'start_offsets', 'offsets'],
                              coords={
                                  self.channel_name: self.channels,
                                  'start_offsets': self.start_offsets.copy(),
                                  'offsets': np.arange(self.read_size),
                                  'samplerate': self.params_dict['samplerate']

                              }
                              )

        from copy import deepcopy
        eventdata.attrs = deepcopy(self.params_dict)

        return eventdata, read_ok_mask

 def test_expand_without_dims(self):
     from satpy.resample import NativeResampler
     import numpy as np
     import dask.array as da
     from xarray import DataArray
     from pyresample.geometry import AreaDefinition
     from pyresample.utils import proj4_str_to_dict
     ds1 = DataArray(da.zeros((100, 50), chunks=85))
     proj_dict = proj4_str_to_dict('+proj=lcc +datum=WGS84 +ellps=WGS84 '
                                   '+lon_0=-95. +lat_0=25 +lat_1=25 '
                                   '+units=m +no_defs')
     target = AreaDefinition(
         'test',
         'test',
         'test',
         proj_dict,
         x_size=100,
         y_size=200,
         area_extent=(-1000., -1500., 1000., 1500.),
     )
     # source geo def doesn't actually matter
     resampler = NativeResampler(None, target)
     new_arr = resampler.resample(ds1)
     self.assertEqual(new_arr.shape, (200, 100))
     new_arr2 = resampler.resample(ds1.compute())
     self.assertTrue(np.all(new_arr == new_arr2))

 def setUp(self):
     self.values = np.random.randn(4, 6)
     self.data = da.from_array(self.values, chunks=(2, 2))
     self.eager_array = DataArray(self.values, coords={'x': range(4)},
                                  dims=('x', 'y'), name='foo')
     self.lazy_array = DataArray(self.data, coords={'x': range(4)},
                                 dims=('x', 'y'), name='foo')

def test_decode_cf_time_bounds():

    da = DataArray(np.arange(6, dtype='int64').reshape((3, 2)),
                   coords={'time': [1, 2, 3]},
                   dims=('time', 'nbnd'), name='time_bnds')

    attrs = {'units': 'days since 2001-01',
             'calendar': 'standard',
             'bounds': 'time_bnds'}

    ds = da.to_dataset()
    ds['time'].attrs.update(attrs)
    _update_bounds_attributes(ds.variables)
    assert ds.variables['time_bnds'].attrs == {'units': 'days since 2001-01',
                                               'calendar': 'standard'}
    dsc = decode_cf(ds)
    assert dsc.time_bnds.dtype == np.dtype('M8[ns]')
    dsc = decode_cf(ds, decode_times=False)
    assert dsc.time_bnds.dtype == np.dtype('int64')

    # Do not overwrite existing attrs
    ds = da.to_dataset()
    ds['time'].attrs.update(attrs)
    bnd_attr = {'units': 'hours since 2001-01', 'calendar': 'noleap'}
    ds['time_bnds'].attrs.update(bnd_attr)
    _update_bounds_attributes(ds.variables)
    assert ds.variables['time_bnds'].attrs == bnd_attr

    # If bounds variable not available do not complain
    ds = da.to_dataset()
    ds['time'].attrs.update(attrs)
    ds['time'].attrs['bounds'] = 'fake_var'
    _update_bounds_attributes(ds.variables)

def loopread(tcoutput, size_record, ncol, n_alt, size_head, size_data_record, tReq):
    tcoutput = Path(tcoutput).expanduser()
    n_t = tcoutput.stat().st_size // size_record // d_bytes

    chi = empty(n_t, float)
    t = empty(n_t, datetime)

    plasmaparam = DataArray(data=empty((n_t, n_alt, 4)), dims=["time", "alt_km", "isrparam"])
    iono = DataArray(data=empty((n_t, n_alt, 22)), dims=["time", "alt_km", "param"])

    with tcoutput.open("rb") as f:  # reset to beginning
        for i in range(n_t):
            iono[i, ...], chi[i], t[i], alt, plasmaparam[i, ...] = data_tra(
                f, size_record, ncol, n_alt, size_head, size_data_record
            )
        # FIXME isn't there a way to inherit coordinates like Pandas?
        iono = iono.assign_coords(time=t, param=PARAM, alt_km=alt)
        plasmaparam = plasmaparam.assign_coords(time=t, isrparam=ISRPARAM, alt_km=alt)
    #%% handle time request -- will return Dataframe if tReq, else returns Panel of all times
    if tReq is not None:  # have to qualify this since picktime default gives last time as fallback
        tUsedInd = picktime(iono.time, tReq, None)[0]
        if tUsedInd is not None:  # in case ind is 0
            iono = iono[tUsedInd, ...]
            plasmaparam = plasmaparam[tUsedInd, ...]

    return iono, chi, plasmaparam

    def test_returnXArray(self):
        cdo = Cdo()
        cdo.debug = DEBUG

        if not cdo.hasXarray:
          print("nothing testes for test_returnXArray because of missing xarray")
          return

        topo = cdo.topo(options='-f nc',returnXArray='topo')
        self.assertEqual(-1889,int(topo.mean()))
        self.assertEqual(259200,topo.count())

        bathy = cdo.setrtomiss(0,10000, input = " -topo" ,returnXArray='topo')
        self.assertEqual(-3385,int(bathy.mean()))
        self.assertEqual(173565,bathy.count())

        oro = cdo.setrtomiss(-10000,0,
            input = cdo.topo(options='-f nc'),returnXArray='topo')
        self.assertEqual(1142,int(oro.mean()))
        self.assertEqual(85567,oro.count())

        bathy = cdo.remapnn('r2x2',input = cdo.topo(options = '-f nc'), returnXArray = 'topo')
        self.assertEqual(-4298.0,bathy[0,0])
        self.assertEqual(-2669.0,bathy[0,1])

        ta = cdo.remapnn('r2x2',input = cdo.topo(options = '-f nc'))
        tb = cdo.subc(-2669.0,input = ta)
        withMask = cdo.div(input=ta+" "+tb,returnXArray='topo')
        from xarray import DataArray
        self.assertEqual(False,DataArray.to_masked_array(withMask).mask[0,0])
        self.assertEqual(False,DataArray.to_masked_array(withMask).mask[1,0])
        self.assertEqual(False,DataArray.to_masked_array(withMask).mask[1,1])
        self.assertEqual(True,DataArray.to_masked_array(withMask).mask[0,1])

def test_mask_valid_data():
    from xarray import DataArray, Dataset
    import numpy as np
    test_attrs = {
        'one': 1,
        'nodata': -999,
    }

    expected_data_array = DataArray(np.array([[1., np.nan, np.nan], [2, 3, np.nan], [np.nan, np.nan, np.nan]],
                                             dtype='float'),
                                    attrs=test_attrs, name='var_one')

    data_array = DataArray([[1, -999, -999], [2, 3, -999], [-999, -999, -999]], attrs=test_attrs)
    dataset = Dataset(data_vars={'var_one': data_array}, attrs={'ds_attr': 'still here'})

    # Make sure test is actually changing something
    assert not data_array.equals(expected_data_array)

    output_ds = mask_valid_data(dataset, keep_attrs=True)
    assert output_ds.attrs['ds_attr'] == 'still here'
    assert output_ds.data_vars['var_one'].equals(expected_data_array)
    assert output_ds.data_vars['var_one'].attrs['one'] == 1

    output_da = mask_valid_data(data_array, keep_attrs=True)
    assert output_da.equals(expected_data_array)
    assert output_da.attrs['one'] == 1

def cyclic_dataarray(da, coord='lon'):
    """ Add a cyclic coordinate point to a DataArray along a specified
    named coordinate dimension.

    >>> from xarray import DataArray
    >>> data = DataArray([[1, 2, 3], [4, 5, 6]],
    ...                      coords={'x': [1, 2], 'y': range(3)},
    ...                      dims=['x', 'y'])
    >>> cd = cyclic_dataarray(data, 'y')
    >>> print cd.data
    array([[1, 2, 3, 1],
           [4, 5, 6, 4]])
    """
    assert isinstance(da, DataArray)

    lon_idx = da.dims.index(coord)
    cyclic_data, cyclic_coord = add_cyclic_point(da.values,
                                                 coord=da.coords[coord],
                                                 axis=lon_idx)

    # Copy and add the cyclic coordinate and data
    new_coords = dict(da.coords)
    new_coords[coord] = cyclic_coord
    new_values = cyclic_data

    new_da = DataArray(new_values, dims=da.dims, coords=new_coords)

    # Copy the attributes for the re-constructed data and coords
    for att, val in da.attrs.items():
        new_da.attrs[att] = val
    for c in da.coords:
        for att in da.coords[c].attrs:
            new_da.coords[c].attrs[att] = da.coords[c].attrs[att]

    return new_da

 def test_subplot_kws(self):
     a = easy_array((10, 15, 4))
     d = DataArray(a, dims=["y", "x", "z"])
     d.coords["z"] = list("abcd")
     g = d.plot(x="x", y="y", col="z", col_wrap=2, cmap="cool", subplot_kws=dict(axisbg="r"))
     for ax in g.axes.flat:
         self.assertEqual(ax.get_axis_bgcolor(), "r")

    def setUp(self):
        a = easy_array((10, 15, 3, 2))
        darray = DataArray(a, dims=["y", "x", "col", "row"])
        darray.coords["col"] = np.array(["col" + str(x) for x in darray.coords["col"].values])
        darray.coords["row"] = np.array(["row" + str(x) for x in darray.coords["row"].values])

        self.darray = darray

def construct_dataarray(dim_num, dtype, contains_nan, dask):
    # dimnum <= 3
    rng = np.random.RandomState(0)
    shapes = [16, 8, 4][:dim_num]
    dims = ('x', 'y', 'z')[:dim_num]

    if np.issubdtype(dtype, np.floating):
        array = rng.randn(*shapes).astype(dtype)
    elif np.issubdtype(dtype, np.integer):
        array = rng.randint(0, 10, size=shapes).astype(dtype)
    elif np.issubdtype(dtype, np.bool_):
        array = rng.randint(0, 1, size=shapes).astype(dtype)
    elif dtype == str:
        array = rng.choice(['a', 'b', 'c', 'd'], size=shapes)
    else:
        raise ValueError
    da = DataArray(array, dims=dims, coords={'x': np.arange(16)}, name='da')

    if contains_nan:
        da = da.reindex(x=np.arange(20))
    if dask and has_dask:
        chunks = {d: 4 for d in dims}
        da = da.chunk(chunks)

    return da

    def __init__(self, data,
                 coords=None,
                 dims=None,
                 name=None,
                 attrs=None,
                 encoding=None,
                 fastpath=False
                 ):

        if major_x_ver == 0 and minor_x_ver < 7:

            DataArray.__init__(self, data=data,
                               coords=coords,
                               dims=dims,
                               name=name,
                               attrs=attrs,
                               encoding=encoding,
                               # fastpath=fastpath
                               )
        else:
            DataArray.__init__(self, data=data,
                               coords=coords,
                               dims=dims,
                               name=name,
                               attrs=attrs,
                               encoding=encoding,
                               fastpath=fastpath
                               )

 def test_datetime_dimension(self):
     nrow = 3
     ncol = 4
     time = pd.date_range("2000-01-01", periods=nrow)
     a = DataArray(easy_array((nrow, ncol)), coords=[("time", time), ("y", range(ncol))])
     a.plot()
     ax = plt.gca()
     self.assertTrue(ax.has_data())

 def test_subplot_kws(self):
     a = easy_array((10, 15, 4))
     d = DataArray(a, dims=['y', 'x', 'z'])
     d.coords['z'] = list('abcd')
     g = d.plot(x='x', y='y', col='z', col_wrap=2, cmap='cool',
                subplot_kws=dict(axisbg='r'))
     for ax in g.axes.flat:
         self.assertEqual(ax.get_axis_bgcolor(), 'r')

    def setUp(self):
        a = easy_array((10, 15, 3, 2))
        darray = DataArray(a, dims=['y', 'x', 'col', 'row'])
        darray.coords['col'] = np.array(['col' + str(x) for x in
                                         darray.coords['col'].values])
        darray.coords['row'] = np.array(['row' + str(x) for x in
                                         darray.coords['row'].values])

        self.darray = darray

 def test_stack(self):
     data = da.random.normal(size=(2, 3, 4), chunks=(1, 3, 4))
     arr = DataArray(data, dims=('w', 'x', 'y'))
     stacked = arr.stack(z=('x', 'y'))
     z = pd.MultiIndex.from_product([np.arange(3), np.arange(4)],
                                    names=['x', 'y'])
     expected = DataArray(data.reshape(2, -1), {'z': z}, dims=['w', 'z'])
     assert stacked.data.chunks == expected.data.chunks
     self.assertLazyAndEqual(expected, stacked)

    def test_convenient_facetgrid_4d(self):
        a = easy_array((10, 15, 2, 3))
        d = DataArray(a, dims=["y", "x", "columns", "rows"])
        g = d.plot(x="x", y="y", col="columns", row="rows")

        self.assertArrayEqual(g.axes.shape, [3, 2])
        for ax in g.axes.flat:
            self.assertTrue(ax.has_data())

        with self.assertRaisesRegexp(ValueError, "[Ff]acet"):
            d.plot(x="x", y="y", col="columns", ax=plt.gca())

 def test_dataarray_pickle(self):
     # Test that pickling/unpickling does not convert the dask
     # backend to numpy
     a1 = DataArray(build_dask_array())
     a1.compute()
     self.assertFalse(a1._in_memory)
     self.assertEquals(kernel_call_count, 1)
     a2 = pickle.loads(pickle.dumps(a1))
     self.assertEquals(kernel_call_count, 1)
     self.assertDataArrayIdentical(a1, a2)
     self.assertFalse(a1._in_memory)
     self.assertFalse(a2._in_memory)