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
