def test_geometry_3(self):
"""Test nodes in a file with no node count variable."""
f = cfdm.read(self.geometry_3_file, verbose=False)
self.assertEqual(len(f), 2, "f = " + repr(f))
for g in f:
self.assertTrue(g.equals(g.copy(), verbose=3))
self.assertEqual(len(g.auxiliary_coordinates()), 3)
g = f[0]
for axis in ("X", "Y", "Z"):
coord = g.construct("axis=" + axis)
self.assertFalse(coord.has_node_count(), "axis=" + axis)
self.assertFalse(coord.has_part_node_count(), "axis=" + axis)
self.assertFalse(coord.has_interior_ring(), "axis=" + axis)
cfdm.write(f, tempfile, Conventions="CF-" + VN, verbose=False)
f2 = cfdm.read(tempfile, verbose=False)
self.assertEqual(len(f2), 2, "f2 = " + repr(f2))
for a, b in zip(f, f2):
self.assertTrue(a.equals(b, verbose=3))
def test_geometry_interior_ring(self):
if self.test_only and inspect.stack()[0][3] not in self.test_only:
return
f = cfdm.read(self.geometry_interior_ring_file, verbose=False)
self.assertTrue(len(f) == 2, 'f = ' + repr(f))
for g in f:
self.assertTrue(g.equals(g.copy(), verbose=True))
self.assertTrue(len(g.auxiliary_coordinates) == 4)
# g.dump()
g = f[0]
for axis in ('X', 'Y', 'Z'):
coord = g.construct('axis=' + axis)
self.assertTrue(coord.has_node_count(), 'axis=' + axis)
self.assertTrue(coord.has_part_node_count(), 'axis=' + axis)
self.assertTrue(coord.has_interior_ring(), 'axis=' + axis)
cfdm.write(f, self.tempfilename, Conventions='CF-1.8', verbose=False)
# cfdm.write(f, 'delme.nc', Conventions='CF-1.8', verbose=False)
f2 = cfdm.read(self.tempfilename, verbose=False)
self.assertTrue(len(f2) == 2, 'f2 = ' + repr(f2))
for a, b in zip(f, f2):
self.assertTrue(a.equals(b, verbose=True))
def test_geometry_4(self):
if self.test_only and inspect.stack()[0][3] not in self.test_only:
return
f = cfdm.read(self.geometry_4_file, verbose=False)
self.assertEqual(len(f), 2, 'f = ' + repr(f))
for g in f:
self.assertTrue(g.equals(g.copy(), verbose=3))
self.assertEqual(len(g.auxiliary_coordinates), 3)
for axis in ('X', 'Y'):
coord = g.construct('axis=' + axis)
self.assertTrue(coord.has_node_count(), 'axis=' + axis)
self.assertFalse(coord.has_part_node_count(), 'axis=' + axis)
self.assertFalse(coord.has_interior_ring(), 'axis=' + axis)
cfdm.write(f, tempfile, Conventions='CF-' + VN, verbose=False)
f2 = cfdm.read(tempfile, verbose=False)
self.assertEqual(len(f2), 2, 'f2 = ' + repr(f2))
for a, b in zip(f, f2):
self.assertTrue(a.equals(b, verbose=3))
# Setting of node count properties
coord = f[0].construct('axis=X')
nc = coord.get_node_count()
cfdm.write(f, tempfile)
nc.set_property('long_name', 'Node counts')
cfdm.write(f, tempfile, verbose=False)
nc.nc_set_variable('new_var_name')
cfdm.write(f, tempfile, verbose=False)
def test_DSG_indexed_contiguous(self):
if self.test_only and inspect.stack()[0][3] not in self.test_only:
return
f = cfdm.read(self.indexed_contiguous, verbose=False)
self.assertTrue(len(f) == 2)
# Select the specific humidity field
q = [g for g in f
if g.get_property('standard_name') == 'specific_humidity'][0]
qa = q.data.array
message= repr(qa-self.b) +'\n'+repr(qa[2,0])+'\n'+repr(self.b[2, 0])
self.assertTrue(q._equals(qa, self.b), message)
# print ('\nf\n')
# for x in f:
# print(x)
cfdm.write(f, self.tempfilename, verbose=False)
g = cfdm.read(self.tempfilename, verbose=False)
# print ('\ng\n')
# for x in g:
# print(x)
self.assertTrue(len(g) == len(f))
for i in range(len(f)):
self.assertTrue(g[i].equals(f[i], verbose=True))
def test_read_write_multiple_geometries(self):
"""Test reading and writing with a mixture of geometry cells."""
a = []
for filename in (
"geometry_1.nc",
"geometry_2.nc",
"geometry_3.nc",
"geometry_4.nc",
"geometry_interior_ring_2.nc",
"geometry_interior_ring.nc",
):
a.extend(cfdm.read(filename))
for n, f in enumerate(a):
f.set_property("test_id", str(n))
cfdm.write(a, tmpfile, verbose=1)
f = cfdm.read(tmpfile, verbose=1)
self.assertEqual(len(a), len(f))
for x in a:
for n, y in enumerate(f[:]):
if x.equals(y):
f.pop(n)
break
self.assertFalse(f)
def test_geometry_3(self):
if self.test_only and inspect.stack()[0][3] not in self.test_only:
return
f = cfdm.read(self.geometry_3_file, verbose=False)
self.assertEqual(len(f), 2, 'f = ' + repr(f))
for g in f:
self.assertTrue(g.equals(g.copy(), verbose=3))
self.assertEqual(len(g.auxiliary_coordinates), 3)
g = f[0]
for axis in ('X', 'Y', 'Z'):
coord = g.construct('axis=' + axis)
self.assertFalse(coord.has_node_count(), 'axis=' + axis)
self.assertFalse(coord.has_part_node_count(), 'axis=' + axis)
self.assertFalse(coord.has_interior_ring(), 'axis=' + axis)
cfdm.write(f, tempfile, Conventions='CF-' + VN, verbose=False)
f2 = cfdm.read(tempfile, verbose=False)
self.assertEqual(len(f2), 2, 'f2 = ' + repr(f2))
for a, b in zip(f, f2):
self.assertTrue(a.equals(b, verbose=3))
def test_read_write_string(self):
"""Test the `string` keyword argument to `read` and `write`."""
f = cfdm.read(self.string_filename)
n = int(len(f) / 2)
for i in range(0, n):
j = i + n
self.assertTrue(
f[i].data.equals(f[j].data, verbose=3),
f"{f[i]!r} {f[j]!r}",
)
self.assertTrue(
f[j].data.equals(f[i].data, verbose=3),
f"{f[j]!r} {f[i]!r}",
)
# Note: Don't loop round all netCDF formats for better
# performance. Just one netCDF3 and one netCDF4 format
# is sufficient to test the functionality
f0 = cfdm.read(self.string_filename)
for string0 in (True, False):
for fmt0 in ("NETCDF4", "NETCDF3_CLASSIC"):
cfdm.write(f0, tmpfile0, fmt=fmt0, string=string0)
for string1 in (True, False):
for fmt1 in ("NETCDF4", "NETCDF3_CLASSIC"):
cfdm.write(f0, tmpfile1, fmt=fmt1, string=string1)
for i, j in zip(cfdm.read(tmpfile1),
cfdm.read(tmpfile0)):
self.assertTrue(i.equals(j, verbose=3))
def test_read_write_string(self):
if self.test_only and inspect.stack()[0][3] not in self.test_only:
return
f = cfdm.read(self.string_filename)
n = int(len(f) / 2)
for i in range(0, n):
j = i + n
self.assertTrue(f[i].data.equals(f[j].data, verbose=3),
"{!r} {!r}".format(f[i], f[j]))
self.assertTrue(f[j].data.equals(f[i].data, verbose=3),
"{!r} {!r}".format(f[j], f[i]))
f0 = cfdm.read(self.string_filename)
for string0 in (True, False):
for fmt0 in ('NETCDF4', 'NETCDF3_CLASSIC'):
cfdm.write(f0, tmpfile0, fmt=fmt0, string=string0)
for string1 in (True, False):
for fmt1 in ('NETCDF4', 'NETCDF3_CLASSIC'):
cfdm.write(f0, tmpfile1, fmt=fmt1, string=string1)
for i, j in zip(cfdm.read(tmpfile1),
cfdm.read(tmpfile0)):
self.assertTrue(i.equals(j, verbose=3))
def test_read_mask(self):
"""Test reading and writing of netCDF with masked data."""
f = cfdm.example_field(0)
N = f.size
f.data[1, 1] = cfdm.masked
f.data[2, 2] = cfdm.masked
f.del_property("_FillValue", None)
f.del_property("missing_value", None)
cfdm.write(f, tmpfile)
g = cfdm.read(tmpfile)[0]
self.assertEqual(numpy.ma.count(g.data.array), N - 2)
g = cfdm.read(tmpfile, mask=False)[0]
self.assertEqual(numpy.ma.count(g.data.array), N)
g.apply_masking(inplace=True)
self.assertEqual(numpy.ma.count(g.data.array), N - 2)
f.set_property("_FillValue", 999)
f.set_property("missing_value", -111)
cfdm.write(f, tmpfile)
g = cfdm.read(tmpfile)[0]
self.assertEqual(numpy.ma.count(g.data.array), N - 2)
g = cfdm.read(tmpfile, mask=False)[0]
self.assertEqual(numpy.ma.count(g.data.array), N)
g.apply_masking(inplace=True)
self.assertEqual(numpy.ma.count(g.data.array), N - 2)
def test_read_write_unlimited(self):
"""Test reading and writing with an unlimited dimension."""
for fmt in self.netcdf_fmts:
f = cfdm.read(self.filename)[0]
domain_axes = f.domain_axes()
domain_axes["domainaxis0"].nc_set_unlimited(True)
cfdm.write(f, tmpfile, fmt=fmt)
f = cfdm.read(tmpfile)[0]
domain_axes = f.domain_axes()
self.assertTrue(domain_axes["domainaxis0"].nc_is_unlimited())
f = cfdm.read(self.filename)[0]
domain_axes = f.domain_axes()
domain_axes["domainaxis0"].nc_set_unlimited(True)
domain_axes["domainaxis2"].nc_set_unlimited(True)
cfdm.write(f, tmpfile, fmt="NETCDF4")
f = cfdm.read(tmpfile)[0]
domain_axes = f.domain_axes()
self.assertTrue(domain_axes["domainaxis0"].nc_is_unlimited())
self.assertTrue(domain_axes["domainaxis2"].nc_is_unlimited())
def test_read_write_multiple_geometries(self):
if self.test_only and inspect.stack()[0][3] not in self.test_only:
return
a = []
for filename in (
'geometry_1.nc',
'geometry_2.nc',
'geometry_3.nc',
'geometry_4.nc',
'geometry_interior_ring_2.nc',
'geometry_interior_ring.nc',
):
a.extend(cfdm.read(filename))
for n, f in enumerate(a):
f.set_property('test_id', str(n))
cfdm.write(a, tmpfile, verbose=1)
f = cfdm.read(tmpfile, verbose=1)
self.assertEqual(len(a), len(f))
for x in a:
for n, y in enumerate(f[:]):
if x.equals(y):
f.pop(n)
break
# --- End: for
self.assertFalse(f)
def test_read_write_Conventions(self):
"""TODO DOCS."""
f = cfdm.read(self.filename)[0]
version = "CF-" + cfdm.CF()
other = "ACDD-1.3"
for Conventions in (other,):
cfdm.write(f, tmpfile0, Conventions=Conventions)
g = cfdm.read(tmpfile0)[0]
self.assertEqual(
g.get_property("Conventions"),
" ".join([version, other]),
"{!r}, {!r}".format(
g.get_property("Conventions"), Conventions
),
)
for Conventions in (
version,
"",
" ",
",",
", ",
):
Conventions = version
cfdm.write(f, tmpfile0, Conventions=Conventions)
g = cfdm.read(tmpfile0)[0]
self.assertEqual(
g.get_property("Conventions"),
version,
"{!r}, {!r}".format(
g.get_property("Conventions"), Conventions
),
)
for Conventions in (
[version],
[version, other],
):
cfdm.write(f, tmpfile0, Conventions=Conventions)
g = cfdm.read(tmpfile0)[0]
self.assertEqual(
g.get_property("Conventions"),
" ".join(Conventions),
"{!r}, {!r}".format(
g.get_property("Conventions"), Conventions
),
)
for Conventions in ([other, version],):
cfdm.write(f, tmpfile0, Conventions=Conventions)
g = cfdm.read(tmpfile0)[0]
self.assertEqual(
g.get_property("Conventions"),
" ".join([version, other]),
"{!r}, {!r}".format(
g.get_property("Conventions"), Conventions
),
)
def test_geometry_4(self):
"""Test nodes all not tied to auxiliary coordinate variables."""
f = cfdm.read(self.geometry_4_file, verbose=False)
self.assertEqual(len(f), 2, "f = " + repr(f))
for g in f:
self.assertTrue(g.equals(g.copy(), verbose=3))
self.assertEqual(len(g.auxiliary_coordinates()), 3)
for axis in ("X", "Y"):
coord = g.construct("axis=" + axis)
self.assertTrue(coord.has_node_count(), "axis=" + axis)
self.assertFalse(coord.has_part_node_count(), "axis=" + axis)
self.assertFalse(coord.has_interior_ring(), "axis=" + axis)
cfdm.write(f, tempfile, Conventions="CF-" + VN, verbose=False)
f2 = cfdm.read(tempfile, verbose=False)
self.assertEqual(len(f2), 2, "f2 = " + repr(f2))
for a, b in zip(f, f2):
self.assertTrue(a.equals(b, verbose=3))
# Setting of node count properties
coord = f[0].construct("axis=X")
nc = coord.get_node_count()
cfdm.write(f, tempfile)
nc.set_property("long_name", "Node counts")
cfdm.write(f, tempfile, verbose=False)
nc.nc_set_variable("new_var_name")
cfdm.write(f, tempfile, verbose=False)
def test_Field_compress_uncompress(self):
"""Test the compress and uncompress Field methods."""
contiguous = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"DSG_timeSeries_contiguous.nc",
)
indexed = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"DSG_timeSeries_indexed.nc",
)
indexed_contiguous = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"DSG_timeSeriesProfile_indexed_contiguous.nc",
)
files = (contiguous, indexed, indexed_contiguous)
methods = ("contiguous", "indexed", "indexed_contiguous")
for filename, method in zip(files, methods):
message = "method=" + method
for f in cfdm.read(filename):
self.assertTrue(bool(f.data.get_compression_type()), message)
u = f.uncompress()
self.assertFalse(bool(u.data.get_compression_type()), message)
self.assertTrue(f.equals(u, verbose=3), message)
for method1 in methods:
message += ", method1=" + method1
if method1 == "indexed_contiguous":
if f.data.ndim != 3:
continue
elif f.data.ndim != 2:
continue
c = u.compress(method1)
self.assertTrue(
bool(c.data.get_compression_type()), message
)
self.assertTrue(u.equals(c, verbose=3), message)
self.assertTrue(f.equals(c, verbose=3), message)
c = f.compress(method1)
self.assertTrue(
bool(c.data.get_compression_type()), message
)
self.assertTrue(u.equals(c, verbose=3), message)
self.assertTrue(f.equals(c, verbose=3), message)
cfdm.write(c, tmpfile)
c = cfdm.read(tmpfile)[0]
self.assertTrue(
bool(c.data.get_compression_type()), message
)
self.assertTrue(f.equals(c, verbose=3), message)
def test_read_write_missing_data(self):
"""Test reading and writing of netCDF with missing data."""
f = cfdm.read(self.filename)[0]
for fmt in self.netcdf_fmts:
cfdm.write(f, tmpfile, fmt=fmt)
g = cfdm.read(tmpfile)[0]
self.assertTrue(f.equals(g, verbose=3),
f"Bad read/write of format: {fmt}")
def test_groups_compression(self):
f = cfdm.example_field(4)
ungrouped_file = ungrouped_file3
grouped_file = grouped_file3
f.compress('indexed_contiguous', inplace=True)
f.data.get_count().nc_set_variable('count')
f.data.get_index().nc_set_variable('index')
cfdm.write(f, ungrouped_file, verbose=1)
g = cfdm.read(ungrouped_file)[0]
self.assertTrue(f.equals(g, verbose=2))
# ------------------------------------------------------------
# Move the field construct to the /forecast/model group
# ------------------------------------------------------------
g.nc_set_variable_groups(['forecast', 'model'])
# ------------------------------------------------------------
# Move the count variable to the /forecast group
# ------------------------------------------------------------
g.data.get_count().nc_set_variable_groups(['forecast'])
# ------------------------------------------------------------
# Move the index variable to the /forecast group
# ------------------------------------------------------------
g.data.get_index().nc_set_variable_groups(['forecast'])
# ------------------------------------------------------------
# Move the coordinates that span the element dimension to the
# /forecast group
# ------------------------------------------------------------
name = 'altitude'
g.construct(name).nc_set_variable_groups(['forecast'])
# ------------------------------------------------------------
# Move the sample dimension to the /forecast group
# ------------------------------------------------------------
g.data.get_count().nc_set_sample_dimension_groups(['forecast'])
cfdm.write(g, grouped_file, verbose=1)
nc = netCDF4.Dataset(grouped_file, 'r')
self.assertIn(f.nc_get_variable(),
nc.groups['forecast'].groups['model'].variables)
self.assertIn(f.data.get_count().nc_get_variable(),
nc.groups['forecast'].variables)
self.assertIn(f.data.get_index().nc_get_variable(),
nc.groups['forecast'].variables)
self.assertIn(
f.construct('altitude').nc_get_variable(),
nc.groups['forecast'].variables)
nc.close()
h = cfdm.read(grouped_file, verbose=1)
self.assertEqual(len(h), 1, repr(h))
self.assertTrue(f.equals(h[0], verbose=2))
def test_read_write_unlimited(self):
if self.test_only and inspect.stack()[0][3] not in self.test_only:
return
f = cfdm.read(self.filename)[0]
f.nc_set_unlimited_dimensions(['domainaxis0'])
cfdm.write(f, tmpfile)
f = cfdm.read(tmpfile)[0]
self.assertTrue(f.nc_unlimited_dimensions() == set(['domainaxis0']))
def test_read_write_format(self):
"""Test the `fmt` keyword argument of the `read` function."""
f = cfdm.read(self.filename)[0]
for fmt in self.netcdf_fmts:
cfdm.write(f, tmpfile, fmt=fmt)
g = cfdm.read(tmpfile)
self.assertEqual(len(g), 1)
g = g[0]
self.assertTrue(f.equals(g, verbose=3),
f"Bad read/write of format: {fmt}")
def test_read_write_format(self):
"""TODO DOCS."""
f = cfdm.read(self.filename)[0]
for fmt in self.netcdf_fmts:
cfdm.write(f, tmpfile, fmt=fmt)
g = cfdm.read(tmpfile)
self.assertEqual(len(g), 1)
g = g[0]
self.assertTrue(
f.equals(g, verbose=3), f"Bad read/write of format: {fmt}"
)
def test_read_field(self):
if self.test_only and inspect.stack()[0][3] not in self.test_only:
return
# Test field keyword of cfdm.read
filename = self.filename
f = cfdm.read(filename)
self.assertEqual(len(f), 1, '\n' + str(f))
f = cfdm.read(filename,
extra=['dimension_coordinate'],
warnings=warnings)
self.assertEqual(len(f), 4, '\n' + str(f))
f = cfdm.read(filename,
extra=['auxiliary_coordinate'],
warnings=warnings)
self.assertEqual(len(f), 4, '\n' + str(f))
f = cfdm.read(filename, extra='cell_measure')
self.assertEqual(len(f), 2, '\n' + str(f))
f = cfdm.read(filename, extra=['field_ancillary'])
self.assertEqual(len(f), 4, '\n' + str(f))
f = cfdm.read(filename, extra='domain_ancillary', warnings=warnings)
self.assertEqual(len(f), 4, '\n' + str(f))
f = cfdm.read(filename,
extra=['field_ancillary', 'auxiliary_coordinate'],
warnings=warnings)
self.assertEqual(len(f), 7, '\n' + str(f))
self.assertEqual(
len(
cfdm.read(filename,
extra=['domain_ancillary', 'auxiliary_coordinate'],
warnings=warnings)), 7)
self.assertEqual(
len(
cfdm.read(filename,
extra=[
'domain_ancillary', 'cell_measure',
'auxiliary_coordinate'
],
warnings=warnings)), 8)
f = cfdm.read(filename,
extra=('field_ancillary', 'dimension_coordinate',
'cell_measure', 'auxiliary_coordinate',
'domain_ancillary'),
warnings=warnings)
self.assertEqual(len(f), 14, '\n' + str(f))
def test_read_write_missing_data(self):
if self.test_only and inspect.stack()[0][3] not in self.test_only:
return
f = cfdm.read(self.filename)[0]
for fmt in ('NETCDF3_CLASSIC', 'NETCDF3_64BIT', 'NETCDF3_64BIT_OFFSET',
'NETCDF3_64BIT_DATA', 'NETCDF4', 'NETCDF4_CLASSIC'):
cfdm.write(f, tmpfile, fmt=fmt)
g = cfdm.read(tmpfile)[0]
self.assertTrue(f.equals(g, verbose=3),
'Bad read/write of format: {}'.format(fmt))
def test_write_datatype(self):
if self.test_only and inspect.stack()[0][3] not in self.test_only:
return
f = cfdm.read(self.filename)[0]
self.assertTrue(f.data.dtype == numpy.dtype(float))
cfdm.write(f, tmpfile, fmt='NETCDF4',
datatype={numpy.dtype(float): numpy.dtype('float32')})
g = cfdm.read(tmpfile)[0]
self.assertTrue(g.data.dtype == numpy.dtype('float32'),
'datatype read in is '+str(g.data.dtype))
def test_read_write_Conventions(self):
"""Test the `Conventions` keyword argument to `write`."""
f = cfdm.read(self.filename)[0]
version = "CF-" + cfdm.CF()
other = "ACDD-1.3"
for Conventions in (other, ):
cfdm.write(f, tmpfile0, Conventions=Conventions)
g = cfdm.read(tmpfile0)[0]
self.assertEqual(
g.get_property("Conventions"),
" ".join([version, other]),
f"{g.get_property('Conventions')!r}, {Conventions!r}",
)
for Conventions in (
version,
"",
" ",
",",
", ",
):
Conventions = version
cfdm.write(f, tmpfile0, Conventions=Conventions)
g = cfdm.read(tmpfile0)[0]
self.assertEqual(
g.get_property("Conventions"),
version,
f"{g.get_property('Conventions')!r}, {Conventions!r}",
)
for Conventions in (
[version],
[version, other],
):
cfdm.write(f, tmpfile0, Conventions=Conventions)
g = cfdm.read(tmpfile0)[0]
self.assertEqual(
g.get_property("Conventions"),
" ".join(Conventions),
f"{g.get_property('Conventions')!r}, {Conventions!r}",
)
for Conventions in ([other, version], ):
cfdm.write(f, tmpfile0, Conventions=Conventions)
g = cfdm.read(tmpfile0)[0]
self.assertEqual(
g.get_property("Conventions"),
" ".join([version, other]),
f"{g.get_property('Conventions')!r}, {Conventions!r}",
)
def test_read_write_Conventions(self):
if self.test_only and inspect.stack()[0][3] not in self.test_only:
return
f = cfdm.read(self.filename)[0]
version = 'CF-' + cfdm.CF()
other = 'ACDD-1.3'
for Conventions in (other, ):
cfdm.write(f, tmpfile0, Conventions=Conventions)
g = cfdm.read(tmpfile0)[0]
self.assertEqual(
g.get_property('Conventions'), ' '.join([version, other]),
"{!r}, {!r}".format(g.get_property('Conventions'),
Conventions))
for Conventions in (
version,
'',
' ',
',',
', ',
):
Conventions = version
cfdm.write(f, tmpfile0, Conventions=Conventions)
g = cfdm.read(tmpfile0)[0]
self.assertEqual(
g.get_property('Conventions'), version,
"{!r}, {!r}".format(g.get_property('Conventions'),
Conventions))
for Conventions in (
[version],
[version, other],
):
cfdm.write(f, tmpfile0, Conventions=Conventions)
g = cfdm.read(tmpfile0)[0]
self.assertEqual(
g.get_property('Conventions'), ' '.join(Conventions),
"{!r}, {!r}".format(g.get_property('Conventions'),
Conventions))
for Conventions in ([other, version], ):
cfdm.write(f, tmpfile0, Conventions=Conventions)
g = cfdm.read(tmpfile0)[0]
self.assertEqual(
g.get_property('Conventions'), ' '.join([version, other]),
"{!r}, {!r}".format(g.get_property('Conventions'),
Conventions))
def test_read_write_netCDF4_compress_shuffle(self):
"""TODO DOCS."""
f = cfdm.read(self.filename)[0]
for fmt in self.netcdf4_fmts:
for shuffle in (True,):
for compress in (4,): # range(10):
cfdm.write(
f, tmpfile, fmt=fmt, compress=compress, shuffle=shuffle
)
g = cfdm.read(tmpfile)[0]
self.assertTrue(
f.equals(g, verbose=3),
"Bad read/write with lossless compression: "
f"{fmt}, {compress}, {shuffle}",
)
def test_DSG_indexed_contiguous(self):
"""TODO DOCS."""
f = self.ic.copy()
self.assertEqual(len(f), 2)
# Select the specific humidity field
q = [
g for g in f
if g.get_property("standard_name") == "specific_humidity"
][0]
qa = q.data.array
message = (repr(qa - self.b) + "\n" + repr(qa[2, 0]) + "\n" +
repr(self.b[2, 0]))
self.assertTrue(q._equals(qa, self.b), message)
cfdm.write(f, tempfile)
g = cfdm.read(tempfile)
self.assertEqual(len(g), len(f))
for i in range(len(f)):
self.assertTrue(g[i].equals(f[i], verbose=3))
def test_read_write_netCDF4_compress_shuffle(self):
if self.test_only and inspect.stack()[0][3] not in self.test_only:
return
f = cfdm.read(self.filename)[0]
for fmt in ('NETCDF4',
'NETCDF4_CLASSIC'):
for shuffle in (True, False):
for compress in range(10):
cfdm.write(f, tmpfile, fmt=fmt,
compress=compress,
shuffle=shuffle)
g = cfdm.read(tmpfile)[0]
self.assertTrue(
f.equals(g, verbose=True),
'Bad read/write with lossless compression: {}, {}, {}'.format(fmt, compress, shuffle))
def test_GATHERING(self):
"""Test reading and writing of a field with a gathered array."""
f = cfdm.read(self.gathered, verbose=False)
self.assertEqual(len(f), 3)
for g in f:
if g.get_property("long_name") == "temp3":
break
cfdm.write(f, tempfile, verbose=False)
g = cfdm.read(tempfile, verbose=False)
self.assertEqual(len(g), len(f))
for i in range(len(f)):
self.assertTrue(g[i].equals(f[i], verbose=3))
def test_DSG_indexed_contiguous(self):
if self.test_only and inspect.stack()[0][3] not in self.test_only:
return
f = self.ic.copy()
self.assertEqual(len(f), 2)
# Select the specific humidity field
q = [g for g in f
if g.get_property('standard_name') == 'specific_humidity'][0]
qa = q.data.array
message = (repr(qa-self.b) + '\n' + repr(qa[2, 0]) + '\n' +
repr(self.b[2, 0]))
self.assertTrue(q._equals(qa, self.b), message)
cfdm.write(f, tempfile)
g = cfdm.read(tempfile)
self.assertEqual(len(g), len(f))
for i in range(len(f)):
self.assertTrue(g[i].equals(f[i], verbose=3))
def test_example_field(self):
"""Test the `example_field` function."""
top = 8
example_fields = cfdm.example_fields()
self.assertEqual(len(example_fields), top)
for f in example_fields:
_ = f.data.array
self.assertIsInstance(f.dump(display=False), str)
cfdm.write(f, temp_file)
g = cfdm.read(temp_file, verbose=1)
self.assertEqual(len(g), 1)
self.assertTrue(f.equals(g[0], verbose=3))
with self.assertRaises(Exception):
cfdm.example_field(top + 1)
with self.assertRaises(ValueError):
cfdm.example_field(1, 2)
with self.assertRaises(TypeError):
cfdm.example_field(1, 2, 3)
self.assertEqual(len(cfdm.example_fields(0)), 1)
self.assertEqual(len(cfdm.example_fields(0, 2)), 2)
self.assertEqual(len(cfdm.example_fields(0, 2, 0)), 3)
