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_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_CF_ATOL_RTOL_environment(self):
if self.test_only and inspect.stack()[0][3] not in self.test_only:
return
self.assertTrue(cfdm.CF() == '1.7')
org = cfdm.RTOL()
self.assertTrue(cfdm.RTOL(1e-5) == org)
self.assertTrue(cfdm.RTOL() == 1e-5)
self.assertTrue(cfdm.RTOL(org) == 1e-5)
self.assertTrue(cfdm.RTOL() == org)
org = cfdm.ATOL()
self.assertTrue(cfdm.ATOL(1e-5) == org)
self.assertTrue(cfdm.ATOL() == 1e-5)
self.assertTrue(cfdm.ATOL(org) == 1e-5)
self.assertTrue(cfdm.ATOL() == org)
out = cfdm.environment(display=False)
def test_netCDF_variable_dimension(self):
"""Test variable and dimension access NetCDF methods."""
f = cfdm.Field()
f.nc_set_variable("qwerty")
self.assertTrue(f.nc_has_variable())
self.assertEqual(f.nc_get_variable(), "qwerty")
self.assertEqual(f.nc_get_variable(default=None), "qwerty")
self.assertEqual(f.nc_del_variable(), "qwerty")
self.assertFalse(f.nc_has_variable())
self.assertIsNone(f.nc_get_variable(default=None))
self.assertIsNone(f.nc_del_variable(default=None))
f.nc_set_variable("/ncvar")
self.assertEqual(f.nc_get_variable(), "ncvar")
f.nc_set_variable("/ncvar/qwerty")
self.assertEqual(f.nc_get_variable(), "/ncvar/qwerty")
for nc_var_name in self.nc_grouped_variable_names:
with self.assertRaises(ValueError):
f.nc_set_variable(nc_var_name)
d = cfdm.DomainAxis()
d.nc_set_dimension("qwerty")
self.assertTrue(d.nc_has_dimension())
self.assertEqual(d.nc_get_dimension(), "qwerty")
self.assertEqual(d.nc_get_dimension(default=None), "qwerty")
self.assertEqual(d.nc_del_dimension(), "qwerty")
self.assertFalse(d.nc_has_dimension())
self.assertIsNone(d.nc_get_dimension(default=None))
self.assertIsNone(d.nc_del_dimension(default=None))
d.nc_set_dimension("/ncdim")
self.assertEqual(d.nc_get_dimension(), "ncdim")
d.nc_set_dimension("/ncdim/qwerty")
self.assertEqual(d.nc_get_dimension(), "/ncdim/qwerty")
for nc_dim_name in self.nc_grouped_dimension_names:
with self.assertRaises(ValueError):
d.nc_set_dimension(nc_dim_name)
d = cfdm.Count()
d.nc_set_sample_dimension("qwerty")
self.assertTrue(d.nc_has_sample_dimension())
self.assertEqual(d.nc_get_sample_dimension(), "qwerty")
self.assertEqual(d.nc_get_sample_dimension(default=None), "qwerty")
self.assertEqual(d.nc_del_sample_dimension(), "qwerty")
self.assertFalse(d.nc_has_sample_dimension())
self.assertIsNone(d.nc_get_sample_dimension(default=None))
self.assertIsNone(d.nc_del_sample_dimension(default=None))
d.nc_set_sample_dimension("/ncdim")
self.assertEqual(d.nc_get_sample_dimension(), "ncdim")
d.nc_set_sample_dimension("/ncdim/qwerty")
self.assertEqual(d.nc_get_sample_dimension(), "/ncdim/qwerty")
for nc_dim_name in self.nc_grouped_dimension_names:
with self.assertRaises(ValueError):
d.nc_set_sample_dimension(nc_dim_name)
# ------------------------------------------------------------
# Global attributes
# ------------------------------------------------------------
# values keyword
f = cfdm.Field()
f.nc_set_global_attribute("Conventions", "CF-1.8")
f.nc_set_global_attribute("project")
f.nc_set_global_attribute("foo")
f.set_property("Conventions", "Y")
f.set_property("project", "X")
self.assertEqual(
f.nc_global_attributes(values=True),
{"Conventions": "CF-1.8", "project": "X", "foo": None},
)
f = cfdm.Field()
self.assertEqual(f.nc_clear_global_attributes(), {})
f.nc_set_global_attribute("Conventions")
f.nc_set_global_attribute("project", "X")
self.assertEqual(
f.nc_global_attributes(), {"Conventions": None, "project": "X"}
)
f.nc_set_global_attribute("project")
f.nc_set_global_attribute("comment", None)
self.assertEqual(
f.nc_global_attributes(),
{"Conventions": None, "project": None, "comment": None},
)
self.assertEqual(
f.nc_clear_global_attributes(),
{"Conventions": None, "project": None, "comment": None},
)
self.assertEqual(f.nc_global_attributes(), {})
f.nc_set_global_attribute("Conventions")
f.nc_set_global_attribute("project")
self.assertEqual(
f.nc_global_attributes(), {"Conventions": None, "project": None}
)
_ = f.nc_clear_global_attributes()
f.nc_set_global_attributes({})
self.assertEqual(f.nc_global_attributes(), {})
f.nc_set_global_attributes({"comment": 123}, copy=False)
self.assertEqual(f.nc_global_attributes(), {"comment": 123})
f.nc_set_global_attributes({"comment": None, "foo": "bar"})
self.assertEqual(
f.nc_global_attributes(), {"comment": None, "foo": "bar"}
)
f = cfdm.Field()
f.set_properties({"foo": "bar", "comment": "variable comment"})
f.nc_set_variable("tas")
d = f.set_construct(cfdm.DomainAxis(2))
f.set_data(cfdm.Data([8, 9]), axes=[d])
f2 = f.copy()
f2.nc_set_variable("ua")
cfdm.write(
[f, f2],
tempfile1,
file_descriptors={"comment": "global comment", "qwerty": "asdf"},
)
g = cfdm.read(tempfile1)
self.assertEqual(len(g), 2)
for x in g:
self.assertEqual(
x.properties(),
{
"comment": "variable comment",
"foo": "bar",
"qwerty": "asdf",
"Conventions": "CF-" + cfdm.CF(),
},
)
self.assertEqual(
x.nc_global_attributes(),
{
"comment": "global comment",
"qwerty": None,
"Conventions": None,
},
)
cfdm.write(g, tempfile2)
h = cfdm.read(tempfile2)
for x, y in zip(h, g):
self.assertEqual(x.properties(), y.properties())
self.assertEqual(
x.nc_global_attributes(), y.nc_global_attributes()
)
self.assertTrue(x.equals(y, verbose=3))
self.assertTrue(y.equals(x, verbose=3))
g[1].nc_set_global_attribute("comment", "different comment")
cfdm.write(g, tempfile3)
h = cfdm.read(tempfile3)
for x, y in zip(h, g):
self.assertEqual(x.properties(), y.properties())
self.assertEqual(
x.nc_global_attributes(),
{"comment": None, "qwerty": None, "Conventions": None},
)
self.assertTrue(x.equals(y, verbose=3))
self.assertTrue(y.equals(x, verbose=3))
print("\n**Tutorial**\n")
print("\n**Import**\n")
import cfdm
cfdm.CF()
print("\n**Field construct**\n")
print("\n**Reading field constructs from datasets**\n")
x = cfdm.read('file.nc')
print(type(x))
len(x)
print("\n**Inspection**\n")
x
q = x[0]
t = x[1]
q
print(q)
print(t)
q.dump()
t.dump()
print("\n**Properties**\n")
import datetime
import os
import unittest
import numpy
import faulthandler
faulthandler.enable() # to debug seg faults and timeouts
import netCDF4
import cfdm
VN = cfdm.CF()
# --------------------------------------------------------------------
# DSG files
# --------------------------------------------------------------------
def _make_contiguous_file(filename):
"""Make a netCDF file with a contiguous ragged array DSG feature."""
n = netCDF4.Dataset(filename, "w", format="NETCDF3_CLASSIC")
n.Conventions = "CF-" + VN
n.featureType = "timeSeries"
n.createDimension("station", 4)
n.createDimension("obs", 24)
n.createDimension("name_strlen", 8)
def test_CF(self):
"""Test the CF function."""
self.assertEqual(cfdm.CF(), cfdm.core.__cf_version__)
def test_netCDF_variable_dimension(self):
if self.test_only and inspect.stack()[0][3] not in self.test_only:
return
f = cfdm.Field()
f.nc_set_variable('qwerty')
self.assertTrue(f.nc_has_variable())
self.assertEqual(f.nc_get_variable(), 'qwerty')
self.assertEqual(f.nc_get_variable(default=None), 'qwerty')
self.assertEqual(f.nc_del_variable(), 'qwerty')
self.assertFalse(f.nc_has_variable())
self.assertIsNone(f.nc_get_variable(default=None))
self.assertIsNone(f.nc_del_variable(default=None))
f.nc_set_variable('/ncvar')
self.assertEqual(f.nc_get_variable(), 'ncvar')
f.nc_set_variable('/ncvar/qwerty')
self.assertEqual(f.nc_get_variable(), '/ncvar/qwerty')
with self.assertRaises(ValueError):
f.nc_set_variable(None)
with self.assertRaises(ValueError):
f.nc_set_variable('/')
with self.assertRaises(ValueError):
f.nc_set_variable('group/ncvar')
with self.assertRaises(ValueError):
f.nc_set_variable('group/')
with self.assertRaises(ValueError):
f.nc_set_variable('group/ncvar/')
with self.assertRaises(ValueError):
f.nc_set_variable('/group/ncvar/')
d = cfdm.DomainAxis()
d.nc_set_dimension('qwerty')
self.assertTrue(d.nc_has_dimension())
self.assertEqual(d.nc_get_dimension(), 'qwerty')
self.assertEqual(d.nc_get_dimension(default=None), 'qwerty')
self.assertEqual(d.nc_del_dimension(), 'qwerty')
self.assertFalse(d.nc_has_dimension())
self.assertIsNone(d.nc_get_dimension(default=None))
self.assertIsNone(d.nc_del_dimension(default=None))
d.nc_set_dimension('/ncdim')
self.assertEqual(d.nc_get_dimension(), 'ncdim')
d.nc_set_dimension('/ncdim/qwerty')
self.assertEqual(d.nc_get_dimension(), '/ncdim/qwerty')
with self.assertRaises(ValueError):
d.nc_set_dimension(None)
with self.assertRaises(ValueError):
d.nc_set_dimension('/')
with self.assertRaises(ValueError):
d.nc_set_dimension('group/ncdim')
with self.assertRaises(ValueError):
d.nc_set_dimension('group/')
with self.assertRaises(ValueError):
d.nc_set_dimension('group/ncdim/')
with self.assertRaises(ValueError):
d.nc_set_dimension('/group/ncdim/')
d = cfdm.Count()
d.nc_set_sample_dimension('qwerty')
self.assertTrue(d.nc_has_sample_dimension())
self.assertEqual(d.nc_get_sample_dimension(), 'qwerty')
self.assertEqual(d.nc_get_sample_dimension(default=None), 'qwerty')
self.assertEqual(d.nc_del_sample_dimension(), 'qwerty')
self.assertFalse(d.nc_has_sample_dimension())
self.assertIsNone(d.nc_get_sample_dimension(default=None))
self.assertIsNone(d.nc_del_sample_dimension(default=None))
d.nc_set_sample_dimension('/ncdim')
self.assertEqual(d.nc_get_sample_dimension(), 'ncdim')
d.nc_set_sample_dimension('/ncdim/qwerty')
self.assertEqual(d.nc_get_sample_dimension(), '/ncdim/qwerty')
with self.assertRaises(ValueError):
d.nc_set_sample_dimension(None)
with self.assertRaises(ValueError):
d.nc_set_sample_dimension('/')
with self.assertRaises(ValueError):
d.nc_set_sample_dimension('group/ncdim')
with self.assertRaises(ValueError):
d.nc_set_sample_dimension('group/')
with self.assertRaises(ValueError):
d.nc_set_sample_dimension('group/ncdim/')
with self.assertRaises(ValueError):
d.nc_set_sample_dimension('/group/ncdim/')
# ------------------------------------------------------------
# Global attributes
# ------------------------------------------------------------
# values keyword
f = cfdm.Field()
f.nc_set_global_attribute('Conventions', 'CF-1.8')
f.nc_set_global_attribute('project')
f.nc_set_global_attribute('foo')
f.set_property('Conventions', 'Y')
f.set_property('project', 'X')
self.assertEqual(f.nc_global_attributes(values=True),
{'Conventions': 'CF-1.8',
'project': 'X',
'foo': None})
f = cfdm.Field()
self.assertEqual(f.nc_clear_global_attributes(), {})
f.nc_set_global_attribute('Conventions')
f.nc_set_global_attribute('project', 'X')
self.assertEqual(f.nc_global_attributes(), {'Conventions': None,
'project': 'X'})
f.nc_set_global_attribute('project')
f.nc_set_global_attribute('comment', None)
self.assertEqual(f.nc_global_attributes(), {'Conventions': None,
'project': None,
'comment': None})
self.assertEqual(f.nc_clear_global_attributes(), {'Conventions': None,
'project': None,
'comment': None})
self.assertEqual(f.nc_global_attributes(), {})
f.nc_set_global_attribute('Conventions')
f.nc_set_global_attribute('project')
self.assertEqual(f.nc_global_attributes(), {'Conventions': None,
'project': None})
_ = f.nc_clear_global_attributes()
f.nc_set_global_attributes({})
self.assertEqual(f.nc_global_attributes(), {})
f.nc_set_global_attributes({'comment': 123}, copy=False)
self.assertEqual(f.nc_global_attributes(), {'comment': 123})
f.nc_set_global_attributes({'comment': None, 'foo': 'bar'})
self.assertEqual(f.nc_global_attributes(), {'comment': None,
'foo': 'bar'})
f = cfdm.Field()
f.set_properties({'foo': 'bar', 'comment': 'variable comment'})
f.nc_set_variable('tas')
d = f.set_construct(cfdm.DomainAxis(2))
f.set_data(cfdm.Data([8, 9]), axes=[d])
f2 = f.copy()
f2.nc_set_variable('ua')
cfdm.write([f, f2], tempfile1,
file_descriptors={'comment': 'global comment',
'qwerty': 'asdf'})
g = cfdm.read(tempfile1)
self.assertEqual(len(g), 2)
for x in g:
self.assertEqual(x.properties(), {'comment': 'variable comment',
'foo': 'bar',
'qwerty': 'asdf',
'Conventions': 'CF-'+cfdm.CF()})
self.assertEqual(x.nc_global_attributes(),
{'comment': 'global comment',
'qwerty': None,
'Conventions': None})
cfdm.write(g, tempfile2)
h = cfdm.read(tempfile2)
for x, y in zip(h, g):
self.assertEqual(x.properties(), y.properties())
self.assertEqual(x.nc_global_attributes(),
y.nc_global_attributes())
self.assertTrue(x.equals(y, verbose=3))
self.assertTrue(y.equals(x, verbose=3))
g[1].nc_set_global_attribute('comment', 'different comment')
cfdm.write(g, tempfile3)
h = cfdm.read(tempfile3)
for x, y in zip(h, g):
self.assertEqual(x.properties(), y.properties())
self.assertEqual(x.nc_global_attributes(), {'comment': None,
'qwerty': None,
'Conventions': None})
self.assertTrue(x.equals(y, verbose=3))
self.assertTrue(y.equals(x, verbose=3))
def test_CF(self):
"""TODO DOCS."""
self.assertEqual(cfdm.CF(), cfdm.core.__cf_version__)
def test_CF(self):
if self.test_only and inspect.stack()[0][3] not in self.test_only:
return
self.assertEqual(cfdm.CF(), cfdm.core.__cf_version__)
