def test_init_explicit(self): lat = ArrayCoordinates1d([0, 1, 2], name="lat") lon = ArrayCoordinates1d([10, 20, 30], name="lon") time = ArrayCoordinates1d(["2018-01-01", "2018-01-02", "2018-01-03"], name="time") c = StackedCoordinates([lat, lon, time]) assert c.dims == ("lat", "lon", "time") assert c.udims == ("lat", "lon", "time") assert c.name == "lat_lon_time" repr(c) # un-named lat = ArrayCoordinates1d([0, 1, 2]) lon = ArrayCoordinates1d([10, 20, 30]) time = ArrayCoordinates1d(["2018-01-01", "2018-01-02", "2018-01-03"]) c = StackedCoordinates([lat, lon, time]) assert c.dims == (None, None, None) assert c.udims == (None, None, None) assert c.name is None lat = ArrayCoordinates1d([0, 1, 2], name="lat") c = StackedCoordinates([lat, lon, time]) assert c.dims == ("lat", None, None) assert c.udims == ("lat", None, None) assert c.name == "lat_?_?" repr(c)
def test_reshape(self): lat = np.linspace(0, 1, 12).reshape((3, 4)) lon = np.linspace(10, 20, 12).reshape((3, 4)) c = StackedCoordinates([lat, lon]) assert c.reshape((4, 3)) == StackedCoordinates([lat.reshape((4, 3)), lon.reshape((4, 3))]) assert c.flatten().reshape((3, 4)) == c
def test_transpose_invalid(self): lat = ArrayCoordinates1d([0, 1, 2], name="lat") lon = ArrayCoordinates1d([10, 20, 30], name="lon") time = ArrayCoordinates1d(["2018-01-01", "2018-01-02", "2018-01-03"], name="time") c = StackedCoordinates([lat, lon, time]) with pytest.raises(ValueError, match="Invalid transpose dimensions"): c.transpose("lon", "lat")
def test_copy(self): lat = ArrayCoordinates1d([0, 1, 2], name="lat") lon = ArrayCoordinates1d([10, 20, 30], name="lon") time = ArrayCoordinates1d(["2018-01-01", "2018-01-02", "2018-01-03"], name="time") c = StackedCoordinates([lat, lon, time]) c2 = c.copy() assert c2 is not c assert c2 == c
def test_issubset_other(self): sc = StackedCoordinates([[1, 2, 3], [10, 20, 30]], name="lat_lon") with pytest.raises( TypeError, match= "StackedCoordinates issubset expected Coordinates or StackedCoordinates" ): sc.issubset([])
def test_copy(self): lat = ArrayCoordinates1d([0, 1, 2], name='lat') lon = ArrayCoordinates1d([10, 20, 30], name='lon') time = ArrayCoordinates1d(['2018-01-01', '2018-01-02', '2018-01-03'], name='time') c = StackedCoordinates([lat, lon, time]) c2 = c.copy() assert c2 is not c assert c2 == c
def test_definition(self): lat = ArrayCoordinates1d([0, 1, 2], name="lat") lon = ArrayCoordinates1d([10, 20, 30], name="lon") time = UniformCoordinates1d("2018-01-01", "2018-01-03", "1,D", name="time") c = StackedCoordinates([lat, lon, time]) d = c.definition assert isinstance(d, list) json.dumps(d, cls=podpac.core.utils.JSONEncoder) # test serializable c2 = StackedCoordinates.from_definition(d) assert c2 == c
def test_eq_shaped(self): lat = np.linspace(0, 1, 12).reshape((3, 4)) lon = np.linspace(10, 20, 12).reshape((3, 4)) c1 = StackedCoordinates([lat, lon]) c2 = StackedCoordinates([lat, lon]) c3 = StackedCoordinates([lat[::-1], lon]) c4 = StackedCoordinates([lat, lon[::-1]]) assert c1 == c2 assert c1 != c3 assert c1 != c4
def test_eq_coordinates(self): lat = ArrayCoordinates1d([0, 1, 2], name='lat') lon = ArrayCoordinates1d([10, 20, 30], name='lon') c1 = StackedCoordinates([lat, lon]) c2 = StackedCoordinates([lat, lon]) c3 = StackedCoordinates([lat[::-1], lon]) c4 = StackedCoordinates([lat, lon[::-1]]) assert c1 == c2 assert c1 != c3 assert c1 != c4
def test_from_xarray(self): lat = ArrayCoordinates1d([0, 1, 2], name='lat') lon = ArrayCoordinates1d([10, 20, 30], name='lon') time = ArrayCoordinates1d(['2018-01-01', '2018-01-02', '2018-01-03'], name='time') xcoords = StackedCoordinates([lat, lon, time]).coords c2 = StackedCoordinates.from_xarray(xcoords) assert c2.dims == ('lat', 'lon', 'time') assert_equal(c2['lat'].coordinates, lat.coordinates) assert_equal(c2['lon'].coordinates, lon.coordinates) assert_equal(c2['time'].coordinates, time.coordinates)
def test_from_xarray(self): lat = ArrayCoordinates1d([0, 1, 2], name="lat") lon = ArrayCoordinates1d([10, 20, 30], name="lon") time = ArrayCoordinates1d(["2018-01-01", "2018-01-02", "2018-01-03"], name="time") c = StackedCoordinates([lat, lon, time]) x = xr.DataArray(np.empty(c.shape), coords=c.xcoords, dims=c.xdims) c2 = StackedCoordinates.from_xarray(x.coords) assert c2.dims == ("lat", "lon", "time") assert_equal(c2["lat"].coordinates, lat.coordinates) assert_equal(c2["lon"].coordinates, lon.coordinates) assert_equal(c2["time"].coordinates, time.coordinates)
def test_select_single_shaped(self): lat = np.linspace(0, 1, 12).reshape((3, 4)) lon = np.linspace(10, 20, 12).reshape((3, 4)) c = StackedCoordinates([lat, lon], dims=["lat", "lon"]) # single dimension bounds = {"lat": [0.25, 0.55]} E0, E1 = [0, 1, 1, 1], [3, 0, 1, 2] # expected s = c.select(bounds) assert isinstance(s, StackedCoordinates) assert s == c[E0, E1] s, I = c.select(bounds, return_index=True) assert isinstance(s, StackedCoordinates) assert s == c[I] assert s == c[E0, E1] # a different single dimension bounds = {"lon": [12.5, 17.5]} E0, E1 = [0, 1, 1, 1, 1, 2], [3, 0, 1, 2, 3, 0] s = c.select(bounds) assert isinstance(s, StackedCoordinates) assert s == c[E0, E1] s, I = c.select(bounds, return_index=True) assert isinstance(s, StackedCoordinates) assert s == c[I] assert s == c[E0, E1] # outer bounds = {"lat": [0.25, 0.75]} E0, E1 = [0, 0, 1, 1, 1, 1, 2, 2], [2, 3, 0, 1, 2, 3, 0, 1] s = c.select(bounds, outer=True) assert isinstance(s, StackedCoordinates) assert s == c[E0, E1] s, I = c.select(bounds, outer=True, return_index=True) assert isinstance(s, StackedCoordinates) assert s == c[I] assert s == c[E0, E1] # no matching dimension bounds = {"alt": [0, 10]} s = c.select(bounds) assert s == c s, I = c.select(bounds, return_index=True) assert s == c[I] assert s == c
def test_xcoords_shaped(self): lat = np.linspace(0, 1, 12).reshape((3, 4)) lon = np.linspace(10, 20, 12).reshape((3, 4)) c = StackedCoordinates([lat, lon], dims=["lat", "lon"]) assert isinstance(c.xcoords, dict) x = xr.DataArray(np.empty(c.shape), dims=c.xdims, coords=c.xcoords) assert_equal(x.coords["lat"], c["lat"].coordinates) assert_equal(x.coords["lon"], c["lon"].coordinates) c = StackedCoordinates([lat, lon]) with pytest.raises(ValueError, match="Cannot get xcoords"): c.xcoords
def test_unique(self): lat = ArrayCoordinates1d([0, 1, 2, 1, 0, 5], name="lat") lon = ArrayCoordinates1d([10, 20, 20, 20, 10, 60], name="lon") c = StackedCoordinates([lat, lon]) c2 = c.unique() assert_equal(c2["lat"].coordinates, [0, 1, 2, 5]) assert_equal(c2["lon"].coordinates, [10, 20, 20, 60]) c2, I = c.unique(return_index=True) assert_equal(c2["lat"].coordinates, [0, 1, 2, 5]) assert_equal(c2["lon"].coordinates, [10, 20, 20, 60]) assert c[I] == c2
def test_bounds_shaped(self): lat = np.linspace(0, 1, 12).reshape((3, 4)) lon = np.linspace(10, 20, 12).reshape((3, 4)) c = StackedCoordinates([lat, lon], dims=["lat", "lon"]) bounds = c.bounds assert isinstance(bounds, dict) assert set(bounds.keys()) == set(c.udims) assert_equal(bounds["lat"], c["lat"].bounds) assert_equal(bounds["lon"], c["lon"].bounds) c = StackedCoordinates([lat, lon]) with pytest.raises(ValueError, match="Cannot get bounds"): c.bounds
def test_select_multiple_shaped(self): lat = np.linspace(0, 1, 12).reshape((3, 4)) lon = np.linspace(10, 20, 12).reshape((3, 4)) c = StackedCoordinates([lat, lon], dims=["lat", "lon"]) # this should be the AND of both intersections bounds = {"lat": [0.25, 0.95], "lon": [10.5, 17.5]} E0, E1 = [0, 1, 1, 1, 1, 2], [3, 0, 1, 2, 3, 0] s = c.select(bounds) assert s == c[E0, E1] s, I = c.select(bounds, return_index=True) assert s == c[I] assert s == c[E0, E1]
def test_unque_shaped(self): lat = ArrayCoordinates1d([[0, 1, 2], [1, 0, 5]], name="lat") lon = ArrayCoordinates1d([[10, 20, 20], [20, 10, 60]], name="lon") c = StackedCoordinates([lat, lon]) # flattens c2 = c.unique() assert_equal(c2["lat"].coordinates, [0, 1, 2, 5]) assert_equal(c2["lon"].coordinates, [10, 20, 20, 60]) c2, I = c.unique(return_index=True) assert_equal(c2["lat"].coordinates, [0, 1, 2, 5]) assert_equal(c2["lon"].coordinates, [10, 20, 20, 60]) assert c.flatten()[I] == c2
def test_bounds(self): lat = [0, 1, 2] lon = [10, 20, 30] c = StackedCoordinates([lat, lon], dims=["lat", "lon"]) bounds = c.bounds assert isinstance(bounds, dict) assert set(bounds.keys()) == set(c.udims) assert_equal(bounds["lat"], c["lat"].bounds) assert_equal(bounds["lon"], c["lon"].bounds) c = StackedCoordinates([lat, lon]) with pytest.raises(ValueError, match="Cannot get bounds"): c.bounds
def test_definition(self): lat = ArrayCoordinates1d([0, 1, 2], name='lat') lon = ArrayCoordinates1d([10, 20, 30], name='lon') time = UniformCoordinates1d('2018-01-01', '2018-01-03', '1,D', name='time') c = StackedCoordinates([lat, lon, time]) d = c.definition assert isinstance(d, list) json.dumps(d, cls=podpac.core.utils.JSONEncoder) # test serializable c2 = StackedCoordinates.from_definition(d) assert c2 == c
def test_transpose_in_place(self): lat = ArrayCoordinates1d([0, 1, 2], name="lat") lon = ArrayCoordinates1d([10, 20, 30], name="lon") time = ArrayCoordinates1d(["2018-01-01", "2018-01-02", "2018-01-03"], name="time") c = StackedCoordinates([lat, lon, time]) t = c.transpose("lon", "lat", "time", in_place=False) assert c.dims == ("lat", "lon", "time") assert t.dims == ("lon", "lat", "time") c.transpose("lon", "lat", "time", in_place=True) assert c.dims == ("lon", "lat", "time") assert t["lat"] == lat assert t["lon"] == lon assert t["time"] == time
def test_definition_shaped(self): lat = np.linspace(0, 1, 12).reshape((3, 4)) lon = np.linspace(10, 20, 12).reshape((3, 4)) c = StackedCoordinates([lat, lon], dims=["lat", "lon"]) d = c.definition assert isinstance(d, list) assert len(d) == 2 # serializable json.dumps(d, cls=podpac.core.utils.JSONEncoder) # from definition c2 = StackedCoordinates.from_definition(d) assert c2 == c
def test_get_index(self): lat = ArrayCoordinates1d([0, 1, 2, 3], name='lat') lon = ArrayCoordinates1d([10, 20, 30, 40], name='lon') time = ArrayCoordinates1d( ['2018-01-01', '2018-01-02', '2018-01-03', '2018-01-04'], name='time') c = StackedCoordinates([lat, lon, time]) # integer index assert isinstance(c[0], StackedCoordinates) assert c[0].size == 1 assert c[0].dims == c.dims assert_equal(c[0]['lat'].coordinates, c['lat'].coordinates[0]) # index array assert isinstance(c[[1, 2]], StackedCoordinates) assert c[[1, 2]].size == 2 assert c[[1, 2]].dims == c.dims assert_equal(c[[1, 2]]['lat'].coordinates, c['lat'].coordinates[[1, 2]]) # boolean array assert isinstance(c[[False, True, True, False]], StackedCoordinates) assert c[[False, True, True, False]].size == 2 assert c[[False, True, True, False]].dims == c.dims assert_equal(c[[False, True, True, False]]['lat'].coordinates, c['lat'].coordinates[[False, True, True, False]]) # slice assert isinstance(c[1:3], StackedCoordinates) assert c[1:3].size == 2 assert c[1:3].dims == c.dims assert_equal(c[1:3]['lat'].coordinates, c['lat'].coordinates[1:3])
def test_invalid_coords(self): lat = ArrayCoordinates1d([0, 1, 2], name="lat") lon = ArrayCoordinates1d([0, 1, 2, 3], name="lon") c = ArrayCoordinates1d([0, 1, 2]) with pytest.raises(ValueError, match="Stacked coords must have at least 2 coords"): StackedCoordinates([lat]) with pytest.raises(ValueError, match="Shape mismatch in stacked coords"): StackedCoordinates([lat, lon]) with pytest.raises(ValueError, match="Duplicate dimension"): StackedCoordinates([lat, lat]) # (but duplicate None name is okay) StackedCoordinates([c, c])
def test_invalid_coords_shaped(self): # same size, different shape lat = ArrayCoordinates1d(np.arange(12).reshape((3, 4)), name="lat") lon = ArrayCoordinates1d(np.arange(12).reshape((4, 3)), name="lon") with pytest.raises(ValueError, match="Shape mismatch in stacked coords"): StackedCoordinates([lat, lon])
def test_coordinates(self): lat = ArrayCoordinates1d([0, 1, 2, 3], name="lat") lon = ArrayCoordinates1d([10, 20, 30, 40], name="lon") time = ArrayCoordinates1d(["2018-01-01", "2018-01-02", "2018-01-03", "2018-01-04"], name="time") c = StackedCoordinates([lat, lon, time]) assert_equal(c.coordinates, np.array([lat.coordinates, lon.coordinates, time.coordinates]).T) assert c.coordinates.dtype == object # single dtype lat = ArrayCoordinates1d([0, 1, 2, 3], name="lat") lon = ArrayCoordinates1d([10, 20, 30, 40], name="lon") c = StackedCoordinates([lat, lon]) assert_equal(c.coordinates, np.array([lat.coordinates, lon.coordinates]).T) assert c.coordinates.dtype == float
def test_coercion_shaped_with_name(self): lat = [[0, 1, 2], [10, 11, 12]] lon = [[10, 20, 30], [11, 21, 31]] c = StackedCoordinates([lat, lon], name="lat_lon") assert c.dims == ("lat", "lon") assert_equal(c["lat"].coordinates, lat) assert_equal(c["lon"].coordinates, lon)
def test_len(self): lat = ArrayCoordinates1d([0, 1, 2, 3]) lon = ArrayCoordinates1d([10, 20, 30, 40]) time = ArrayCoordinates1d(["2018-01-01", "2018-01-02", "2018-01-03", "2018-01-04"]) c = StackedCoordinates([lat, lon, time]) assert len(c) == 3
def points(cls, coord_ref_sys=None, ctype=None, distance_units=None, dims=None, **kwargs): """ Create a list of multidimensional coordinates. Valid coordinate values: * single coordinate value (number, datetime64, or str) * array of coordinate values * ``(start, stop, step)`` tuple for uniformly-spaced coordinates * Coordinates1d object Note that the coordinates for each dimension must be the same size. This is equivalent to creating stacked coordinates with a list of coordinate values and a stacked dimension name:: podpac.Coordinates.points(lat=[0, 1, 2], lon=[10, 20, 30], dims=['lat', 'lon']) podpac.Coordinates([[[0, 1, 2], [10, 20, 30]]], dims=['lan_lon']) Arguments --------- lat : optional coordinates for the latitude dimension lon : optional coordinates for the longitude dimension alt : optional coordinates for the altitude dimension time : optional coordinates for the time dimension dims : list of str, optional in Python>=3.6 List of dimension names, must match the provided keyword arguments. In Python 3.6 and above, the ``dims`` argument is optional, and the dims will match the order of the provided keyword arguments. coord_ref_sys : str, optional Default coordinates reference system ctype : str, optional Default coordinates type. One of 'point', 'midpoint', 'left', 'right'. distance_units : Units Default distance units. Returns ------- :class:`Coordinates` podpac Coordinates See Also -------- grid """ coords = cls._coords_from_dict(kwargs, order=dims) stacked = StackedCoordinates(coords) return cls([stacked], coord_ref_sys=coord_ref_sys, ctype=ctype, distance_units=distance_units)
def test_coercion_with_name(self): lat = [0, 1, 2] lon = [10, 20, 30] c = StackedCoordinates([lat, lon], name="lat_lon") assert c.dims == ("lat", "lon") assert_equal(c["lat"].coordinates, lat) assert_equal(c["lon"].coordinates, lon)
def test_size(self): lat = ArrayCoordinates1d([0, 1, 2, 3]) lon = ArrayCoordinates1d([10, 20, 30, 40]) time = ArrayCoordinates1d( ['2018-01-01', '2018-01-02', '2018-01-03', '2018-01-04']) c = StackedCoordinates([lat, lon, time]) assert c.size == 4