def test_grid(self):
"""Test that dataset has the correct data proxies for grids."""
dataset = DAPHandler("http://localhost:8001/", self.app1).dataset
self.assertEqual(dataset.keys(), ["SimpleGrid", "x", "y"])
self.assertEqual(dataset.SimpleGrid.keys(), ["SimpleGrid", "x", "y"])
# test one of the axis
self.assertIsInstance(dataset.SimpleGrid.x.data, BaseProxy)
self.assertEqual(dataset.SimpleGrid.x.data.baseurl,
"http://localhost:8001/")
self.assertEqual(dataset.SimpleGrid.x.data.id, "SimpleGrid.x")
self.assertEqual(dataset.SimpleGrid.x.data.dtype, np.dtype('>i4'))
self.assertEqual(dataset.SimpleGrid.x.data.shape, (3, ))
self.assertEqual(dataset.SimpleGrid.x.data.slice, (slice(None), ))
# test the grid
self.assertIsInstance(dataset.SimpleGrid.SimpleGrid.data, BaseProxy)
self.assertEqual(dataset.SimpleGrid.SimpleGrid.data.baseurl,
"http://localhost:8001/")
self.assertEqual(dataset.SimpleGrid.SimpleGrid.data.id,
"SimpleGrid.SimpleGrid")
self.assertEqual(dataset.SimpleGrid.SimpleGrid.data.dtype,
np.dtype('>i4'))
self.assertEqual(dataset.SimpleGrid.SimpleGrid.data.shape, (2, 3))
self.assertEqual(dataset.SimpleGrid.SimpleGrid.data.slice,
(slice(None), slice(None)))
self.assertEqual(
repr(dataset.SimpleGrid[:]),
"<GridType with array 'SimpleGrid' and maps 'x', 'y'>")
def open_url(url):
dataset = DAPHandler(url).dataset
# attach server-side functions
dataset.functions = Functions(url)
return dataset
def test_sequence(self):
"""Test that dataset has the correct data proxies for sequences."""
dataset = DAPHandler("http://localhost:8001/", self.app2).dataset
self.assertEqual(dataset.keys(), ["cast"])
self.assertEqual(dataset.cast.keys(), [
'id', 'lon', 'lat', 'depth', 'time', 'temperature', 'salinity',
'pressure'
])
# check the sequence
self.assertIsInstance(dataset.cast.data, SequenceProxy)
self.assertEqual(dataset.cast.data.baseurl, "http://localhost:8001/")
self.assertEqual(dataset.cast.data.id, "cast")
self.assertEqual(dataset.cast.data.shape, ())
self.assertEqual(dataset.cast.data.selection, [])
self.assertEqual(dataset.cast.data.slice, (slice(None), ))
# check a child
self.assertIsInstance(dataset.cast.lon.data, SequenceProxy)
self.assertEqual(dataset.cast.lon.data.baseurl,
"http://localhost:8001/")
self.assertEqual(dataset.cast.lon.data.id, "cast.lon")
self.assertEqual(dataset.cast.lon.data.shape, ())
self.assertEqual(dataset.cast.lon.data.dtype, np.dtype(">i4"))
self.assertEqual(dataset.cast.lon.data.selection, [])
self.assertEqual(dataset.cast.lon.data.slice, (slice(None), ))
def test_grid_output_grid_false(self):
"""Test that dataset has the correct data proxies for grids with
option output_grid set to False."""
dataset = DAPHandler("http://localhost:8001/", self.app1,
output_grid=False).dataset
self.assertEqual(list(dataset.keys()), ["SimpleGrid", "x", "y"])
self.assertEqual(
list(dataset.SimpleGrid.keys()), ["SimpleGrid", "x", "y"])
# test one of the axis
self.assertIsInstance(dataset.SimpleGrid.x.data, BaseProxy)
self.assertEqual(
dataset.SimpleGrid.x.data.baseurl, "http://localhost:8001/")
self.assertEqual(dataset.SimpleGrid.x.data.id, "SimpleGrid.x")
self.assertEqual(dataset.SimpleGrid.x.data.dtype, np.dtype('>i4'))
self.assertEqual(dataset.SimpleGrid.x.data.shape, (3,))
self.assertEqual(
dataset.SimpleGrid.x.data.slice, (slice(None),))
# test the grid
self.assertIsInstance(dataset.SimpleGrid.SimpleGrid.data, BaseProxy)
self.assertEqual(
dataset.SimpleGrid.SimpleGrid.data.baseurl,
"http://localhost:8001/")
self.assertEqual(
dataset.SimpleGrid.SimpleGrid.data.id, "SimpleGrid.SimpleGrid")
self.assertEqual(
dataset.SimpleGrid.SimpleGrid.data.dtype, np.dtype('>i4'))
self.assertEqual(dataset.SimpleGrid.SimpleGrid.data.shape, (2, 3))
self.assertEqual(
dataset.SimpleGrid.SimpleGrid.data.slice,
(slice(None), slice(None)))
np.testing.assert_array_equal(dataset.SimpleGrid[:],
[[0, 1, 2], [3, 4, 5]])
def test_sequence(self):
"""Test that dataset has the correct data proxies for sequences."""
dataset = DAPHandler("http://localhost:8001/", self.app2).dataset
self.assertEqual(list(dataset.keys()), ["cast"])
self.assertEqual(
list(dataset.cast.keys()), [
'id', 'lon', 'lat', 'depth', 'time', 'temperature', 'salinity',
'pressure'])
# check the sequence
self.assertIsInstance(dataset.cast.data, SequenceProxy)
self.assertEqual(
dataset.cast.data.baseurl, "http://localhost:8001/")
self.assertEqual(dataset.cast.data.id, "cast")
self.assertEqual(dataset.cast.data.shape, ())
self.assertEqual(dataset.cast.data.selection, [])
self.assertEqual(dataset.cast.data.slice, (slice(None),))
# check a child
self.assertIsInstance(dataset.cast.lon.data, SequenceProxy)
self.assertEqual(
dataset.cast.lon.data.baseurl, "http://localhost:8001/")
self.assertEqual(dataset.cast.lon.data.id, "cast.lon")
self.assertEqual(dataset.cast.lon.data.shape, ())
self.assertEqual(dataset.cast.lon.data.dtype, np.dtype(">i4"))
self.assertEqual(dataset.cast.lon.data.selection, [])
self.assertEqual(dataset.cast.lon.data.slice, (slice(None),))
def test_grid_gzip(self):
"""Test that dataset has the correct data proxies for grids."""
dataset = DAPHandler("http://localhost:8001/", self.app3).dataset
self.assertEqual(list(dataset.keys()), ["SimpleGrid", "x", "y"])
self.assertEqual(
list(dataset.SimpleGrid.keys()), ["SimpleGrid", "x", "y"])
# test one of the axis
self.assertIsInstance(dataset.SimpleGrid.x.data, BaseProxy)
self.assertEqual(
dataset.SimpleGrid.x.data.baseurl, "http://localhost:8001/")
self.assertEqual(dataset.SimpleGrid.x.data.id, "SimpleGrid.x")
self.assertEqual(dataset.SimpleGrid.x.data.dtype, np.dtype('>i4'))
self.assertEqual(dataset.SimpleGrid.x.data.shape, (3,))
self.assertEqual(
dataset.SimpleGrid.x.data.slice, (slice(None),))
# test the grid
self.assertIsInstance(dataset.SimpleGrid.SimpleGrid.data, BaseProxy)
self.assertEqual(
dataset.SimpleGrid.SimpleGrid.data.baseurl,
"http://localhost:8001/")
self.assertEqual(
dataset.SimpleGrid.SimpleGrid.data.id, "SimpleGrid.SimpleGrid")
self.assertEqual(
dataset.SimpleGrid.SimpleGrid.data.dtype, np.dtype('>i4'))
self.assertEqual(dataset.SimpleGrid.SimpleGrid.data.shape, (2, 3))
self.assertEqual(
dataset.SimpleGrid.SimpleGrid.data.slice,
(slice(None), slice(None)))
self.assertEqual(
repr(dataset.SimpleGrid[:]),
"<GridType with array 'SimpleGrid' and maps 'x', 'y'>")
def test_grid_output_grid_false(self):
"""Test that dataset has the correct data proxies for grids with
option output_grid set to False."""
dataset = DAPHandler("http://localhost:8001/",
self.app1,
output_grid=False).dataset
self.assertEqual(dataset.keys(), ["SimpleGrid", "x", "y"])
self.assertEqual(dataset.SimpleGrid.keys(), ["SimpleGrid", "x", "y"])
# test one of the axis
self.assertIsInstance(dataset.SimpleGrid.x.data, BaseProxy)
self.assertEqual(dataset.SimpleGrid.x.data.baseurl,
"http://localhost:8001/")
self.assertEqual(dataset.SimpleGrid.x.data.id, "SimpleGrid.x")
self.assertEqual(dataset.SimpleGrid.x.data.dtype, np.dtype('>i4'))
self.assertEqual(dataset.SimpleGrid.x.data.shape, (3, ))
self.assertEqual(dataset.SimpleGrid.x.data.slice, (slice(None), ))
# test the grid
self.assertIsInstance(dataset.SimpleGrid.SimpleGrid.data, BaseProxy)
self.assertEqual(dataset.SimpleGrid.SimpleGrid.data.baseurl,
"http://localhost:8001/")
self.assertEqual(dataset.SimpleGrid.SimpleGrid.data.id,
"SimpleGrid.SimpleGrid")
self.assertEqual(dataset.SimpleGrid.SimpleGrid.data.dtype,
np.dtype('>i4'))
self.assertEqual(dataset.SimpleGrid.SimpleGrid.data.shape, (2, 3))
self.assertEqual(dataset.SimpleGrid.SimpleGrid.data.slice,
(slice(None), slice(None)))
np.testing.assert_array_equal(dataset.SimpleGrid[:],
[[0, 1, 2], [3, 4, 5]])
def test_grid(self):
"""Test that dataset has the correct data proxies for grids."""
dataset = DAPHandler("http://localhost:8001/", self.app1).dataset
self.assertEqual(dataset.keys(), ["SimpleGrid", "x", "y"])
self.assertEqual(
dataset.SimpleGrid.keys(), ["SimpleGrid", "x", "y"])
# test one of the axis
self.assertIsInstance(dataset.SimpleGrid.x.data, BaseProxy)
self.assertEqual(
dataset.SimpleGrid.x.data.baseurl, "http://localhost:8001/")
self.assertEqual(dataset.SimpleGrid.x.data.id, "SimpleGrid.x")
self.assertEqual(dataset.SimpleGrid.x.data.dtype, np.dtype('>i4'))
self.assertEqual(dataset.SimpleGrid.x.data.shape, (3,))
self.assertEqual(
dataset.SimpleGrid.x.data.slice, (slice(None),))
# test the grid
self.assertIsInstance(dataset.SimpleGrid.SimpleGrid.data, BaseProxy)
self.assertEqual(
dataset.SimpleGrid.SimpleGrid.data.baseurl,
"http://localhost:8001/")
self.assertEqual(
dataset.SimpleGrid.SimpleGrid.data.id, "SimpleGrid.SimpleGrid")
self.assertEqual(
dataset.SimpleGrid.SimpleGrid.data.dtype, np.dtype('>i4'))
self.assertEqual(dataset.SimpleGrid.SimpleGrid.data.shape, (2, 3))
self.assertEqual(
dataset.SimpleGrid.SimpleGrid.data.slice,
(slice(None), slice(None)))
def open_url(url, application=None, session=None):
"""Open a remote URL, returning a dataset."""
dataset = DAPHandler(url, application, session).dataset
# attach server-side functions
dataset.functions = Functions(url, application, session)
return dataset
def open_url(url, application=None, session=None, output_grid=True):
"""
Open a remote URL, returning a dataset.
set output_grid to False to retrieve only main arrays and
never retrieve coordinate axes.
"""
dataset = DAPHandler(url, application, session, output_grid).dataset
# attach server-side functions
dataset.functions = Functions(url, application, session)
return dataset
def open_url(url, application=None, session=None, output_grid=True):
"""
Open a remote URL, returning a dataset.
set output_grid to False to retrieve only main arrays and
never retrieve coordinate axes.
"""
dataset = DAPHandler(url, application, session, output_grid).dataset
# attach server-side functions
dataset.functions = Functions(url, application, session)
return dataset
def test_grid_array_with_projection(self):
"""Test that a grid array can be properly pre sliced."""
dataset = DAPHandler("http://localhost:8001/?SimpleGrid.SimpleGrid[0]",
self.app1).dataset
# object should be a structure, not a grid
self.assertEqual(dataset.keys(), ["SimpleGrid"])
self.assertNotIsInstance(dataset.SimpleGrid, GridType)
self.assertIsInstance(dataset.SimpleGrid, StructureType)
self.assertEqual(dataset.SimpleGrid.SimpleGrid.data.shape, (1, 3))
self.assertEqual(dataset.SimpleGrid.SimpleGrid.data.slice,
(slice(0, 1, 1), slice(0, 3, 1)))
def test_grid_array_with_projection(self):
"""Test that a grid array can be properly pre sliced."""
dataset = DAPHandler(
"http://localhost:8001/?SimpleGrid.SimpleGrid[0]",
self.app1).dataset
# object should be a structure, not a grid
self.assertEqual(list(dataset.keys()), ["SimpleGrid"])
self.assertNotIsInstance(dataset.SimpleGrid, GridType)
self.assertIsInstance(dataset.SimpleGrid, StructureType)
self.assertEqual(dataset.SimpleGrid.SimpleGrid.data.shape, (1, 3))
self.assertEqual(
dataset.SimpleGrid.SimpleGrid.data.slice,
(slice(0, 1, 1), slice(0, 3, 1)))
def test_grid_map_with_projection(self):
"""Test that a grid map can be properly pre sliced."""
dataset = DAPHandler("http://localhost:8001/?SimpleGrid.x[0]",
self.app1).dataset
self.assertEqual(dataset.SimpleGrid.x.data.shape, (1, ))
self.assertEqual(dataset.SimpleGrid.x.data.slice, (slice(0, 1, 1), ))
def test_base_type_with_projection(self):
"""Test that a sliced proxy can be created for a base type."""
dataset = DAPHandler("http://localhost:8001/?x[1:1:2]",
self.app1).dataset
self.assertEqual(dataset.x.data.shape, (2, ))
self.assertEqual(dataset.x.data.slice, (slice(1, 2, 1), ))
def setUp(self):
"""Create a WSGI app"""
self.app = BaseHandler(SimpleSequence)
self.local = SimpleSequence.cast.data
dataset = DAPHandler("http://localhost:8001/", self.app).dataset
self.remote = dataset.cast.data
def test_sequence_with_projection(self):
"""Test projections applied to sequences."""
dataset = DAPHandler("http://localhost:8001/?cast[1]",
self.app2).dataset
self.assertEqual(dataset.cast.data.slice, (slice(1, 2, 1), ))
self.assertEqual([tuple(row) for row in dataset.cast],
[('2', 200, 10, 500, 1, 15, 35, 100)])
def setUp(self):
"""Create a WSGI app with array data"""
dataset = DatasetType("test")
self.original_data = np.array([["This ", "is "], ["a ", "test"]],
dtype='<U5')
dataset["s"] = BaseType("s", self.original_data)
self.app = BaseHandler(dataset)
self.data = DAPHandler("http://localhost:8001/", self.app).dataset.s
def test_open(simple_data, simple_application):
"""Test that NetCDFHandler can be read through open_url."""
dataset = DAPHandler("http://localhost:8001/", simple_application).dataset
dtype = [('index', '<i4'), ('temperature', '<f8'), ('station', 'S40')]
retrieved_data = list(
zip(dataset['index'][:], dataset['temperature'].array[:],
dataset['station'].array[:]))
np.testing.assert_array_equal(np.array(retrieved_data, dtype=dtype),
np.array(simple_data, dtype=dtype))
def test_open(simple_data, simple_data_file):
"""Test that dataset has the correct data proxies for grids."""
dataset = DAPHandler("http://localhost:8001/",
CSVHandler(simple_data_file)).dataset
seq = dataset['sequence']
dtype = [('index', '<i4'), ('temperature', '<f8'), ('site', 'S40')]
retrieved_data = [line for line in seq]
np.testing.assert_array_equal(np.array(retrieved_data, dtype=dtype),
np.array(simple_data, dtype=dtype))
def test_grid_erddap_output_grid_false(self):
"""Test that dataset has the correct data proxies for grids with
option output_grid set to False and with the ERDDAP behavior."""
with patch('pydap.handlers.lib.degenerate_grid_to_structure',
side_effect=(lambda x: x)) as mock_degenerate:
dataset = DAPHandler("http://localhost:8001/", self.app1,
output_grid=False).dataset
np.testing.assert_array_equal(dataset.SimpleGrid[:],
[[0, 1, 2], [3, 4, 5]])
assert mock_degenerate.called
def test_grid_erddap(self):
"""Test that dataset has the correct data proxies for grids
with the ERDDAP behavior."""
with patch('pydap.handlers.lib.degenerate_grid_to_structure',
side_effect=(lambda x: x)) as mock_degenerate:
dataset = DAPHandler("http://localhost:8001/", self.app1).dataset
self.assertEqual(
repr(dataset.SimpleGrid[:]),
"<GridType with array 'SimpleGrid' and maps 'x', 'y'>")
assert mock_degenerate.called
def test_grid_with_projection(self):
"""Test that a sliced proxy can be created for grids."""
dataset = DAPHandler("http://localhost:8001/?SimpleGrid[0]",
self.app1).dataset
self.assertEqual(dataset.SimpleGrid.x.data.shape, (1, ))
self.assertEqual(dataset.SimpleGrid.x.data.slice, (slice(0, 1, 1), ))
self.assertEqual(dataset.SimpleGrid.y.data.shape, (2, ))
self.assertEqual(dataset.SimpleGrid.y.data.slice, (slice(0, 3, 1), ))
self.assertEqual(dataset.SimpleGrid.SimpleGrid.data.shape, (1, 3))
self.assertEqual(dataset.SimpleGrid.SimpleGrid.data.slice,
(slice(0, 1, 1), slice(0, 3, 1)))
def open_url(url):
return DAPHandler(url).dataset
