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_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_issubset_shaped(self):
lat = np.arange(12).reshape(3, 4)
lon = 10 * np.arange(12).reshape(3, 4)
time = 100 * np.arange(12).reshape(3, 4)
dc = StackedCoordinates([lat, lon], dims=["lat", "lon"])
dc_2 = StackedCoordinates([lat + 100, lon],
dims=["lat", "lon"]) # different coordinates
dc_3 = StackedCoordinates(
[lat[::-1], lon],
dims=["lat", "lon"]) # same coordinates, but paired differently
dc_t = dc.transpose("lon", "lat")
dc_shape = StackedCoordinates(
[lat.reshape(6, 2), lon.reshape(6, 2)], dims=["lat", "lon"])
dc_time = StackedCoordinates([lat, lon, time],
dims=["lat", "lon", "time"])
assert dc.issubset(dc)
assert dc[:2, :2].issubset(dc)
assert not dc.issubset(dc[:2, :2])
assert not dc_2.issubset(dc)
assert not dc_3.issubset(dc)
assert dc_t.issubset(dc)
assert dc_shape.issubset(dc)
# extra/missing dimension
assert not dc_time.issubset(dc)
assert not dc.issubset(dc_time)
def test_issubset(self):
lat = np.arange(4)
lon = 10 * np.arange(4)
time = 100 * np.arange(4)
sc = StackedCoordinates([lat, lon], name="lat_lon")
sc_2 = StackedCoordinates([lat + 100, lon],
name="lat_lon") # different coordinates
sc_3 = StackedCoordinates(
[lat[::-1], lon],
name="lat_lon") # same coordinates, paired differently
sc_t = sc.transpose("lon", "lat")
sc_time = StackedCoordinates([lat, lon, time], name="lat_lon_time")
assert sc.issubset(sc)
assert sc[:2].issubset(sc)
assert not sc.issubset(sc[:2])
assert not sc_2.issubset(sc)
assert not sc_3.issubset(sc)
assert sc_t.issubset(sc)
# extra/missing dimension
assert not sc.issubset(sc_time)
assert not sc_time.issubset(sc)
def test_issubset_coordinates_shaped(self):
ulat = np.arange(12)
ulon = 10 * np.arange(12)
utime = 100 * np.arange(12)
lat = ulat.reshape(3, 4)
lon = ulon.reshape(3, 4)
time = utime.reshape(3, 4)
dc = StackedCoordinates([lat, lon], dims=["lat", "lon"])
dc_2 = StackedCoordinates([lat + 100, lon], dims=["lat", "lon"]) # different coordinates
dc_3 = StackedCoordinates([lat[::-1], lon], dims=["lat", "lon"]) # same coordinates, but paired differently
dc_t = dc.transpose("lon", "lat")
dc_shape = StackedCoordinates([lat.reshape(6, 2), lon.reshape(6, 2)], dims=["lat", "lon"])
dc_time = StackedCoordinates([lat, lon, time], dims=["lat", "lon", "time"])
# coordinates with stacked lat_lon
cs = podpac.Coordinates([[ulat, ulon]], dims=["lat_lon"])
assert dc.issubset(cs)
assert dc[:2, :3].issubset(cs)
assert dc[::-1].issubset(cs)
assert not dc_2.issubset(cs)
assert not dc_3.issubset(cs)
assert dc_t.issubset(cs)
assert dc_shape.issubset(cs)
assert not dc_time.issubset(cs)
# coordinates with dependent lat,lon
cd = podpac.Coordinates([[lat, lon]], dims=["lat_lon"])
assert dc.issubset(cd)
assert dc[:2, :3].issubset(cd)
assert dc[::-1].issubset(cd)
assert not dc_2.issubset(cd)
assert not dc_3.issubset(cd)
assert dc_t.issubset(cd)
assert dc_shape.issubset(cd)
assert not dc_time.issubset(cd)
# coordinates with unstacked lat, lon
cu = podpac.Coordinates([ulat, ulon[::-1]], dims=["lat", "lon"])
assert dc.issubset(cu)
assert dc[:2, :3].issubset(cu)
assert dc[::-1].issubset(cu)
assert not dc_2.issubset(cu)
assert dc_3.issubset(cu) # this is an important case!
assert dc_t.issubset(cu)
assert dc_shape.issubset(cu)
assert not dc_time.issubset(cu)
# coordinates with unstacked lat, lon, time
cu_time = podpac.Coordinates([ulat, ulon, utime], dims=["lat", "lon", "time"])
assert dc.issubset(cu_time)
assert dc[:2, :3].issubset(cu_time)
assert dc[::-1].issubset(cu_time)
assert not dc_2.issubset(cu_time)
assert dc_3.issubset(cu_time)
assert dc_t.issubset(cu_time)
assert dc_shape.issubset(cu_time)
assert dc_time.issubset(cu_time)
assert not dc.issubset(cu_time[:2, :, :])
# mixed coordinates
cmixed = podpac.Coordinates([[ulat, ulon], utime], dims=["lat_lon", "time"])
assert dc.issubset(cmixed)
assert dc[:2, :3].issubset(cmixed)
assert dc[::-1].issubset(cmixed)
assert not dc_2.issubset(cmixed)
assert not dc_3.issubset(cmixed)
assert dc_t.issubset(cmixed)
assert dc_shape.issubset(cmixed)
assert dc_time.issubset(cmixed) # this is the most general case
assert not dc.issubset(cmixed[:2, :])
assert not dc_time.issubset(cmixed[:, :1])
def test_issubset_coordinates(self):
lat = np.arange(4)
lon = 10 * np.arange(4)
time = 100 * np.arange(4)
sc = StackedCoordinates([lat, lon], name="lat_lon")
sc_2 = StackedCoordinates([lat + 100, lon], name="lat_lon")
sc_3 = StackedCoordinates([lat[::-1], lon], name="lat_lon")
sc_t = sc.transpose("lon", "lat")
sc_time = StackedCoordinates([lat, lon, time], name="lat_lon_time")
# coordinates with stacked lat_lon
cs = podpac.Coordinates([[lat, lon]], dims=["lat_lon"])
assert sc.issubset(cs)
assert sc[:2].issubset(cs)
assert sc[::-1].issubset(cs)
assert not sc_2.issubset(cs)
assert not sc_3.issubset(cs)
assert sc_t.issubset(cs)
assert not sc_time.issubset(cs)
# coordinates with shaped stacked lat_lon
cd = podpac.Coordinates([[lat.reshape((2, 2)), lon.reshape((2, 2))]], dims=["lat_lon"])
assert sc.issubset(cd)
assert sc[:2].issubset(cd)
assert sc[::-1].issubset(cd)
assert not sc_2.issubset(cd)
assert not sc_3.issubset(cd)
assert sc_t.issubset(cd)
assert not sc_time.issubset(cd)
# coordinates with unstacked lat, lon
cu = podpac.Coordinates([lat, lon[::-1]], dims=["lat", "lon"])
assert sc.issubset(cu)
assert sc[:2].issubset(cu)
assert sc[::-1].issubset(cu)
assert not sc_2.issubset(cu)
assert sc_3.issubset(cu) # this is an important case!
assert sc_t.issubset(cu)
assert not sc_time.issubset(cu)
# coordinates with unstacked lat, lon, time
cu_time = podpac.Coordinates([lat, lon, time], dims=["lat", "lon", "time"])
assert sc.issubset(cu_time)
assert sc[:2].issubset(cu_time)
assert sc[::-1].issubset(cu_time)
assert not sc_2.issubset(cu_time)
assert sc_3.issubset(cu_time)
assert sc_t.issubset(cu_time)
assert sc_time.issubset(cu_time)
assert not sc.issubset(cu_time[:2, :, :])
# mixed coordinates
cmixed = podpac.Coordinates([[lat, lon], time], dims=["lat_lon", "time"])
assert sc.issubset(cmixed)
assert sc[:2].issubset(cmixed)
assert sc[::-1].issubset(cmixed)
assert not sc_2.issubset(cmixed)
assert not sc_3.issubset(cmixed)
assert sc_t.issubset(cmixed)
assert sc_time.issubset(cmixed) # this is the most general case
assert not sc.issubset(cmixed[:2, :])
assert not sc_time.issubset(cmixed[:, :1])
