broadcast

Author: marqh

lib/bald/__init__.py

@@ -3,9 +3,9 @@
 
 import h5py
 
-from bald.validation import ContainerValidation
+from bald.validation import ContainerValidation, DatasetValidation
 
-class Container(object):
+class Subject(object):
     def __init__(self, attrs=None):
         """
         attrs: an dictionary of key value pair attributes
@@ -60,9 +60,19 @@ def validate_hdf5(afilepath):
     """
 
     with load(afilepath) as fhandle:
-        root_container = Container(fhandle.attrs)
+        valid = True
+        root_container = Subject(fhandle.attrs)
         root_val = ContainerValidation(root_container)
-        return root_val.is_valid()
+        if not root_val.is_valid():
+            valid = False
+        # iterate through the datasets
+        for name, dataset in fhandle.items():
+            dset = Subject(dataset.attrs)
+            dset_val = DatasetValidation(name, dataset, dset, fhandle)
+            if not dset_val.is_valid():
+                valid = False
+        
+        return valid
 
 
 

lib/bald/tests/integration/test_validation.py

@@ -39,14 +39,30 @@ def test_invalid_uri(self):
             f.close()
             self.assertFalse(bald.validate_hdf5(tfile))
 
-# class TestArrayReference(BaldTestCase):
-#     def test_match_array_reference(self):
-#         with self.temp_filename('.hdf') as tfile:
-#             f = h5py.File(tfile, "w")
-#             f = _fattrs(f)
-#             f = _create_parent_child(f, (11, 17), (11, 17))
-#             f.close()
+class TestArrayReference(BaldTestCase):
+    def test_match_array_reference(self):
+        with self.temp_filename('.hdf') as tfile:
+            f = h5py.File(tfile, "w")
+            f = _fattrs(f)
+            f = _create_parent_child(f, (11, 17), (11, 17))
+            f.close()
+            self.assertTrue(bald.validate_hdf5(tfile))
 
+    def test_misatch_zeroth_array_reference(self):
+        with self.temp_filename('.hdf') as tfile:
+            f = h5py.File(tfile, "w")
+            f = _fattrs(f)
+            f = _create_parent_child(f, (11, 17), (11, 13))
+            f.close()
+            self.assertFalse(bald.validate_hdf5(tfile))
+
+    def test_misatch_oneth_array_reference(self):
+        with self.temp_filename('.hdf') as tfile:
+            f = h5py.File(tfile, "w")
+            f = _fattrs(f)
+            f = _create_parent_child(f, (11, 17), (13, 17))
+            f.close()
+            self.assertFalse(bald.validate_hdf5(tfile))
 
 
 if __name__ == '__main__':

lib/bald/validation.py

@@ -1,4 +1,5 @@
 
+import numpy as np
 import requests
 
 import bald
@@ -14,7 +15,30 @@ def check_uri(uri):
                 result = True
     return result
 
+def valid_array_reference(parray, carray):
+    """
+    Returns boolean.
+    Validates bald array broadcasting rules between a parent array and a child array.
 
+    Args:
+        * parray - a numpy array: the parent of a bald array reference relation
+
+        * carray - a numpy array: the child of a bald array reference relation 
+    """
+    # https://github.com/SciTools/courses/blob/master/course_content/notebooks/numpy_intro.ipynb
+    # https://cs231n.github.io/python-numpy-tutorial/#numpy-broadcasting
+    # http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html
+    # http://scipy.github.io/old-wiki/pages/EricsBroadcastingDoc
+
+    result = True
+    # try numpy broadcast
+    try:
+        _ = np.broadcast(parray, carray)
+    except ValueError:
+        result = False
+
+    return result
+    
 
 class Validation(object):
 
@@ -25,9 +49,10 @@ def exceptions(self):
         exceptions = []
         return exceptions
 
-class ContainerValidation(Validation):
-    def __init__(self, container):
-        self.container = container
+class SubjectValidation(Validation):
+
+    def __init__(self, subject):
+        self.subject = subject
 
     def is_valid(self):
         return not self.exceptions()
@@ -40,23 +65,79 @@ def exceptions(self):
     def check_attr_uris(self, exceptions):
         def _check_uri(uri, exceptions):
             if not check_uri(uri):
+                check_uri(uri)
                 msg = '{} is not resolving as a resource (404).'
                 msg = msg.format(uri)
                 exceptions.append(ValueError(msg))
             return exceptions
 
-        for pref, uri in self.container.prefixes().iteritems():
-            exceptions = _check_uri(self.container.unpack_uri(uri),
-                                    exceptions)
-        for attr, value in self.container.attrs.iteritems():
-            exceptions = _check_uri(self.container.unpack_uri(attr),
+        for pref, uri in self.subject.prefixes().iteritems():
+            exceptions = _check_uri(self.subject.unpack_uri(uri),
                                     exceptions)
-            exceptions = _check_uri(self.container.unpack_uri(value),
+        for attr, value in self.subject.attrs.iteritems():
+            exceptions = _check_uri(self.subject.unpack_uri(attr),
                                     exceptions)
-
+            if isinstance(value, str):
+                exceptions = _check_uri(self.subject.unpack_uri(value),
+                                        exceptions)
         return exceptions
 
-            
+
+class ContainerValidation(SubjectValidation):
+
+    def __init__(self, container):
+        self.container = container
+        self.subject = container
+
+    def exceptions(self):
+        exceptions = []
+        exceptions = self.check_attr_uris(exceptions)
+        return exceptions
+
+class DatasetValidation(SubjectValidation):
+
+
+    def __init__(self, name, dataset, subject, fhandle):
+        self.dataset = dataset
+        self.subject = subject
+        self.name = name
+        self.fhandle = fhandle
+
+    def exceptions(self):
+        exceptions = []
+        exceptions = self.check_attr_uris(exceptions)
+        exceptions = self.check_array_references(exceptions)
+        return exceptions
+
+    def check_array_references(self, exceptions):
+        def _check_ref(pdataset, parray, cdataset, carray):
+            if not valid_array_reference(parray, carray):
+                msg = ('{} declares a child of {} but the arrays'
+                       'do not conform to the bald array reference'
+                       'rules')
+                msg = msg.format(pdataset, cdataset)
+                exceptions.append(ValueError(msg))
+            return exceptions
+
+        # for dataset in ?????
+        # for parent child relation in dataset
+        # check the broadcasting relationship
+        # parray = np.array((1,2))
+        # carray = np.array((3,4))
+
+        for attr, value in self.subject.attrs.iteritems():
+            # should support subtypes
+            #import pdb; pdb.set_trace()
+            if attr == 'bald_._reference':
+                # check if it's this type, otherwise exception)
+                # if isinstance(value,
+                child_dset = self.fhandle[value]
+                parray = np.zeros(self.dataset.shape)
+                carray = np.zeros(child_dset.shape)
+        
+                exceptions = _check_ref('p', parray, 'c', carray)
+        return exceptions
+
 
 class ValidationSet(Validation):
     pass