onon

Author: marqh

lib/bald/__init__.py

@@ -1,11 +1,48 @@
+import contextlib
+import re
+
 import h5py
 
-import bald.validation
+from bald.validation import ContainerValidation
+
+class Container(object):
+    def __init__(self, attrs=None):
+        """
+        attrs: an dictionary of key value pair attributes
+        """
+        if attrs is None:
+            attrs = []
+        self.attrs = attrs
+        self._prefix_suffix = re.compile('(^(?:(?!_._).)*)_._((?!.*_._).*$)')
+        _http_p = 'http[s]?://.*'
+        self._http_uri = re.compile('{}'.format(_http_p))
+        self._http_uri_prefix = re.compile('{}/|#'.format(_http_p))
+
+
+    def prefixes(self):
+        prefixes = {}
+        for key, value in self.attrs.iteritems():
+            if key.endswith('_._') and self._http_uri_prefix.match(value):
+                pref = key.rstrip('_._')
+                if prefixes.has_key(pref):
+                    raise ValueError('This container has conflicting prefix definitions')
+                prefixes[pref] = value
+        return prefixes
+
 
+    def unpack_uri(self, astring):
+        result = astring
+        if self._prefix_suffix.match(astring):
+            prefix, suffix = self._prefix_suffix.match(astring).groups()
+
+            if self.prefixes().has_key(prefix):
+                if self._http_uri.match(self.prefixes()[prefix]):
+                    result = astring.replace('{}_._'.format(prefix), self.prefixes()[prefix])
+        return result
 
 @contextlib.contextmanager
 def load(afilepath):
-    if afilepath.endswith('.hdf5'):
+    if afilepath.endswith('.hdf'):
         loader = h5py.File
     else:
         raise ValueError('filepath suffix not supported')
@@ -14,14 +51,19 @@ def load(afilepath):
         yield f
     finally:
         f.close()
-    return f
 
-def validate(afilepath):
+
+def validate_hdf5(afilepath):
     """
     Validate a file with respect ot binarry-array-linked-data.
     Returns a :class:`bald.validation.Validation` 
     """
 
-    with load(afilepath) as f:
+    with load(afilepath) as fhandle:
+        root_container = Container(fhandle.attrs)
+        root_val = ContainerValidation(root_container)
+        return root_val.is_valid()
 
+        
+
 

lib/bald/__init__.pyc

@@ -0,0 +1,53 @@
+import unittest
+
+import h5py
+import numpy as np
+
+import bald
+from bald.tests import BaldTestCase
+
+def _fattrs(f):
+    f.attrs['bald_._'] = 'http://binary-array-ld.net/experimental/'
+    f.attrs['bald_._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['bald_._type'] = 'bald_._Dataset'
+    dsetp.attrs['bald_._reference'] = dsetc.ref
+    dsetc.attrs['bald_._type'] = 'bald_._Dataset'
+    return f
+
+
+class Test(BaldTestCase):
+        
+    def test_valid_uri(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_invalid_uri(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.attrs['bald_._turtle'] = 'bald_._walnut'
+            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()
+
+
+
+if __name__ == '__main__':
+    unittest.main()

lib/bald/tests/integration/test_validation.py

@@ -6,7 +6,7 @@
 from bald.tests import BaldTestCase
 
 
-class ATest(BaldTestCase):
+class Test(BaldTestCase):
     def setUp(self):
         self.this = 'this'
 

lib/bald/tests/test_simple.py

@@ -0,0 +1,20 @@
+import unittest
+
+import h5py
+import numpy as np
+
+from bald.tests import BaldTestCase
+from bald import validation
+
+class Test(unittest.TestCase):
+    def test_check_uri_200(self):
+        auri = 'http://binary-array-ld.net/experimental'
+        self.assertTrue(validation.check_uri(auri))
+
+    def test_check_uri_404(self):
+        notauri = 'http://binary-array-ld.net/experimentalish'
+        self.assertFalse(validation.check_uri(notauri))
+
+
+if __name__ == '__main__':
+    unittest.main()

lib/bald/tests/unit/test_validation.py

@@ -1,9 +1,62 @@
 
+import requests
+
+import bald
+
+def check_uri(uri):
+    result = False
+    if uri.startswith('http://') or uri.startswith('https://'):
+        r = requests.get(uri)
+        if r.status_code == 200:
+            headers={'Accept':'text/turtle'}
+            rraw = requests.get(uri, headers=headers)
+            if rraw.status_code == 200:
+                result = True
+    return result
 
 
 
 class Validation(object):
-    pass
+                 
+    def is_valid(self):
+        return not self.exceptions()
+        
+    def exceptions(self):
+        exceptions = []
+        return exceptions
+
+class ContainerValidation(Validation):
+    def __init__(self, container):
+        self.container = container
+
+    def is_valid(self):
+        return not self.exceptions()
+        
+    def exceptions(self):
+        exceptions = []
+        exceptions = self.check_attr_uris(exceptions)
+        return exceptions
+
+    def check_attr_uris(self, exceptions):
+        def _check_uri(uri, exceptions):
+            if not 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),
+                                    exceptions)
+            exceptions = _check_uri(self.container.unpack_uri(value),
+                                    exceptions)
+
+        return exceptions
+    
+            
 
 class ValidationSet(Validation):
     pass
@@ -13,3 +66,4 @@ class ValidationList(Validation):
 
 
 
+#if __name__ == '__main__':