nc array ref

Author: marqh

lib/bald/__init__.py

@@ -104,13 +104,23 @@ def validate_netcdf(afilepath):
     """
 
     with load(afilepath) as fhandle:
+        sval = bv.StoredValidation()
         attrs = {}
         for k in fhandle.ncattrs():
             attrs[k] = getattr(fhandle, k)
         root_container = Subject(attrs)
         root_val = bv.ContainerValidation(subject=root_container,
                                           fhandle=fhandle)
-        return root_val
+        sval.stored_exceptions += root_val.exceptions()
+        for name in fhandle.variables:
+            sattrs = fhandle.__dict__.copy()
+            sattrs.update(fhandle.variables[name].__dict__.copy())
+            var = Subject(sattrs)
+            var_val = bv.ArrayValidation(name, fhandle.variables[name], fhandle=fhandle,
+                                         subject=var)
+            sval.stored_exceptions += var_val.exceptions()
+            
+        return sval
 
 
 def validate_hdf5(afilepath):
@@ -130,8 +140,8 @@ def validate_hdf5(afilepath):
         for name, dataset in fhandle.items():
             # a dataset's attribute collection inherits from and
             # specialises it's container's attrbiute collection
+            # this only helps with prefixes, afaik, hence:
             # #
-            # this only helps with prefixes, afaik
             sattrs = dict(fhandle.attrs).copy()
             sattrs.update(dataset.attrs)
             dset = Subject(sattrs)

lib/bald/tests/integration/test_netcdf.py

@@ -13,15 +13,19 @@ def _fattrs(f):
     f.rdf__type =  'bald__Container'
     return f
 
-# def _create_parent_child(f, pshape, cshape):
-#     dsetp = f.create_dataset("parent_dataset", pshape, dtype='i')
-#     dsetc = f.create_dataset("child_dataset", cshape, dtype='i')
-#     dsetp.attrs['rdf__type'] = 'bald__Dataset'
-#     dsetp.attrs['bald__references'] = dsetc.ref
-#     dsetc.attrs['rdf__type'] = 'bald__Dataset'
-#     dsetc.attrs['rdf__type'] = 'bald__Reference'
-#     dsetc.attrs['bald__dataset'] = dsetc.ref
-#     return f
+def _create_parent_child(f, pshape, cshape):
+    for i, pdimsize in enumerate(pshape):
+        f.createDimension("pdim{}".format(str(i)), pdimsize)
+    for i, cdimsize in enumerate(cshape):
+        f.createDimension("cdim{}".format(str(i)), cdimsize)
+    varp = f.createVariable("parent_variable", 'i4', tuple(["pdim{}".format(str(i)) for i, _ in enumerate(pshape)]))
+    varc = f.createVariable("child_variable", 'i4', tuple(["cdim{}".format(str(i)) for i, _ in enumerate(cshape)]))
+    varp.rdf__type = 'bald__Array'
+    varp.bald__references = "child_variable"
+    varc.rdf__type = 'bald__Array'
+    varc.rdf__type = 'bald__Reference'
+    varc.bald__array = "child_variable"
+    return f
 
 
 class Test(BaldTestCase):
@@ -45,25 +49,25 @@ def test_invalid_uri(self):
             validation = bald.validate_netcdf(tfile)
             self.assertFalse(validation.is_valid())
 
-# class TestArrayReference(BaldTestCase):
-#     def test_match(self):
-#         with self.temp_filename('.nc') as tfile:
-#             f = netCDF4.Dataset(tfile, "w", format="NETCDF4")
-#             f = _fattrs(f)
-#             f = _create_parent_child(f, (11, 17), (11, 17))
-#             f.close()
-#             validation = bald.validate_netcdf(tfile)
-#             self.assertTrue(validation.is_valid())
-
-#     def test_mismatch_zeroth(self):
-#         with self.temp_filename('.nc') as tfile:
-#             f = netCDF4.Dataset(tfile, "w", format="NETCDF4")
-#             f = _fattrs(f)
-#             f = _create_parent_child(f, (11, 17), (11, 13))
-#             f.close()
-#             validation = bald.validate_netcdf(tfile)
-#             self.assertFalse(validation.is_valid())
 
+class TestArrayReference(BaldTestCase):
+    def test_match(self):
+        with self.temp_filename('.nc') as tfile:
+            f = netCDF4.Dataset(tfile, "w", format="NETCDF4")
+            f = _fattrs(f)
+            f = _create_parent_child(f, (11, 17), (11, 17))
+            f.close()
+            validation = bald.validate_netcdf(tfile)
+            self.assertTrue(validation.is_valid())
+
+    def test_mismatch_zeroth(self):
+        with self.temp_filename('.nc') as tfile:
+            f = netCDF4.Dataset(tfile, "w", format="NETCDF4")
+            f = _fattrs(f)
+            f = _create_parent_child(f, (11, 17), (11, 13))
+            f.close()
+            validation = bald.validate_netcdf(tfile)
+            self.assertFalse(validation.is_valid())
 
 
 if __name__ == '__main__':

lib/bald/validation.py

@@ -170,16 +170,19 @@ def _check_ref(parraysubj, parray, carraysubj, carray):
         if self.subject.attrs.get('bald__references', ''):
             # then it must have a bald_array
             ref_dset = self.fhandle[self.subject.attrs.get('bald__references')]
-            if not ref_dset.attrs.get('bald__array', ''):
+            child_dset = None
+            if (hasattr(ref_dset, 'attrs')):
+                child_dset = self.fhandle[ref_dset.attrs.get('bald__array', None)]
+            elif 'bald__array' in ref_dset.ncattrs():
+                child_dset = self.fhandle[ref_dset.bald__array]
+            else:
                 exceptions.append(ValueError('A bald__Reference must link to '
                                              'one and only one bald__Array'))
-            else:
-                # and we impose bald broadcasting rules on it
-                child_dset = self.fhandle[ref_dset.attrs.get('bald__array')]
-                parray = np.zeros(self.array.shape)
-                carray = np.zeros(child_dset.shape)
+            # and we impose bald broadcasting rules on it
+            parray = np.zeros(self.array.shape)
+            carray = np.zeros(child_dset.shape)
 
-                exceptions = _check_ref('p', parray, 'c', carray)
+            exceptions = _check_ref('p', parray, 'c', carray)
 
         return exceptions