Changeset 456

Timestamp:

08/25/10 17:28:08 (21 months ago)

Author:

emuller

Message:

ParameterSchema? and basic validation implemented.

Location:

branches/parameter_set_schema_validation

Files:

• src/parameters/__init__.py (modified) (5 diffs)
• src/parameters/validators.py (modified) (3 diffs)
• test/test_parameters.py (modified) (2 diffs)
• test/test_validators.py (modified) (2 diffs)

branches/parameter_set_schema_validation/src/parameters/__init__.py

@@ -193 +193 @@
             global_dict.update(update_namespace)
 
+        
+        D=None
         try:
             D = eval(s, global_dict)
-        except SyntaxError, e:
+        except SyntaxError as e:
             raise SyntaxError("Invalid string for ParameterSet definition: %s\n%s" % (s,e))
+            
         return D or {}
     
@@ -229 +232 @@
                 pstr = f.read()
                 self._url = initialiser
+
+                
             except IOError:
                 pstr = initialiser
@@ -235 +240 @@
                 f.close()
 
-            initialiser = ParameterSet.read_from_str(pstr,update_namespace)
+
+            # is it a yaml url?
+            if self._url:
+                import urlparse, os.path
+                o = urlparse.urlparse(self._url)
+                base,ext = os.path.splitext(o.path)
+                if ext in ['.yaml','.yml']:
+                    import yaml
+                    initialiser = yaml.load(pstr)
+                else:
+                    initialiser = ParameterSet.read_from_str(pstr,update_namespace)
+            else:
+                initialiser = ParameterSet.read_from_str(pstr,update_namespace)
+
         
         # By this stage, `initialiser` should be a dict. Iterate through it,
@@ -297 +315 @@
         return dict.__getitem__(self,split[0])[split[1]]
 
+    def flat_add(self,name,value):
+        """ Like __setitem__, but it will add ParametSet({}) objects
+        into the namespace tree if needed. """
+
+        split = name.split('.',1)
+        if len(split)==1:
+            dict.__setitem__(self,name,value)
+        else:
+            # nested set
+            try:
+                ps = dict.__getitem__(self,split[0])
+            except KeyError:
+                # setting nested name without parent existing
+                # create parent
+                ps = ParameterSet({})
+                dict.__setitem__(self,split[0],ps)
+                # and try again
+            ps.flat_add(split[1],value)
+
     def __setitem__(self,name,value):
         """ Modified set that detects dots '.' in the names and goes down the
@@ -306 +343 @@
         else:
             # nested set
-            try:
-                dict.__getitem__(self,split[0])[split[1]]=value
-            except KeyError:
-                # setting nested name without parent existing
-                # create parent
-                dict.__setitem__(self,split[0],{})
-                # and try again
-                dict.__getitem__(self,split[0])[split[1]]=value
+            dict.__getitem__(self,split[0])[split[1]]=value
+
    
     # should __len__() be the usual dict length, or the flattened length? Probably the former for consistency with dicts

branches/parameter_set_schema_validation/src/parameters/validators.py

@@ -24 +24 @@
 
     def validate(self, leaf):
-        return issubclass(leaf, type)
+        return isinstance(leaf, self.type)
 
     def __repr__(self):
@@ -77 +77 @@
             value = x[1]
             if isinstance(value, SchemaBase):
-                self[key] = value
+                self.flat_add(key,value)
             else:
-                self[key] = Subclass(type=type(value))
-
-
-
-# Schema ParameterSet types
-
-
-
-
-class CongruencyValidator:
-    pass
-
-
-
+                self.flat_add(key,Subclass(type=type(value)))
+
+
+
+
+class ValidationError(Exception):
+    def __init__(self, path='',schema_base=None, parameter=None ):
+        self.path = path
+        self.schema_base = schema_base
+        self.parameter = parameter
+    def __str__(self):
+        return 'validation error @ %s: parameter "%s" failed against schema: %s' % (self.path, self.parameter, self.schema_base)
+    
+
+
+class CongruencyValidator(object):
+    """
+    A CongruencyValidator validates a ParameterSet against a ParameterSchema
+    either returning True, or raising a ValidationError with the path, SchemaBase subclass
+    and parameter value for which the validation failed.
+
+    The CongruencyValidator expects all names defined in the schema to be present in the parameter set
+    and vice-versa, and will run validation for each item in the namespace tree.
+    
+    The validation functionality is available via the "validate" member
+    CongruencyValidator.validate(parameter_set, parameter_schema)
+
+    example:
+
+    validator = CongruencyValidator()
+
+    try:
+       validator.validate(parameter_set,parameter_schema)
+    except ValidationError, e:
+       
+
+    """
+
+    def __init__(self):
+        pass
+
+
+    def validate(self, parameter_set, parameter_schema):
+        """
+        CongruencyValidator.validate(parameter_set, parameter_schema)
+        
+        validates a ParameterSet against a ParameterSchema
+        either returning True, or raising a ValidationError with the path and SchemaBase subclass
+        for which validation failed.
+
+
+        expects all names defined in the schema to be present in the parameter set
+        and vice-versa, and will run validation for each item in the namespace tree.
+
+        See als0: CongruencyValidator docstring.
+
+        """
+
+        ps = parameter_set
+        schema = parameter_schema
+
+        ps_keys = set()
+        schema_keys = set()
+
+        for path,sb in schema.flat():
+            try:
+                val = ps[path]
+            except KeyError:
+                e = ValidationError(path=path,schema_base=sb,parameter='<MISSING>')
+                raise e
+            if not sb.validate(val):
+                e = ValidationError(path=path,schema_base=sb,parameter=val)
+                raise e
+
+        
+        for path,val in ps.flat():
+            try:
+                sb = schema[path]
+            except KeyError:
+                e = ValidationError(path=path,schema_base='<MISSING>',parameter=val)
+                raise e
+            
+        return True
+        
+            
 
 def congruent_dicts(template, candidate, subset=False,parent_path=''):
@@ -149 +220 @@
 NeuroTools.parameters.Subclass = Subclass
 NeuroTools.parameters.CongruencyValidator = CongruencyValidator
-
-
-    
+NeuroTools.parameters.ValidationError = ValidationError
+
+
+
+
+    

branches/parameter_set_schema_validation/test/test_parameters.py

@@ -86 +86 @@
         ps2 = ParameterSet({'a': 1, 'b':2})
         self.assertEqual(ps1, ps2)
+
+    def test_create_from_flat_iterator(self):
+        ps = ParameterSet({'a':1, 'b':2}, label="PS1")
+        ps2 = ParameterSet({'ps':ps, 'c':19}, label="PS2")
+        ps3 = ParameterSet({'hello': 'world', 'ps2': ps2, 'null': None,
+                            'true': False, 'mylist': [1,2,3,4],
+                            'mydict': {'c': 3, 'd':4}, 'yourlist': [1,2,{'e':5, 'f':6}],
+                            }, label="PS3")
+        ps4 = ParameterSet({})
+        for x in ps3.flat():
+            ps4.flat_add(x[0],x[1])
+        self.assertEqual(ps4, ps3)
+
         
     def test_create_with_syntax_error(self):
@@ -95 +108 @@
     def test_create_with_invalid_initialiser(self):
         self.assertRaises(TypeError, ParameterSet, object)
+
+    def test_create_yaml_url(self):
+        import tempfile, yaml
+
+        conf1_str = """
+        # user info
+        username: joe
+        email:  joe@example.com
+
+        # recipes
+        recipes:
+           all: /somewhere1/file1.xml
+           specific: /somewhere2/file2.xml
+        """
+
+        ps = ParameterSet
+        
+        tf = tempfile.NamedTemporaryFile(suffix='.yaml')
+        tf.file.writelines(conf1_str)
+        
+        tf.file.flush()
+        tf.file.seek(0)
+
+        ps = ParameterSet("file://"+tf.name)
+
+        tf.close()
+
+        ps1 = ParameterSet(yaml.load(conf1_str))
+        assert ps1 == ps
+        
+        
+        
+
     
 class ParameterSetSaveLoadTest(unittest.TestCase):

branches/parameter_set_schema_validation/test/test_validators.py

@@ -48 +48 @@
                            'true': NeuroTools.parameters.validators.Subclass(type=bool), 
                            'yourlist': NeuroTools.parameters.validators.Subclass(type=list), 
-                           'ps2': {'ps.a': NeuroTools.parameters.validators.Subclass(type=int), 
-                                   'c': NeuroTools.parameters.validators.Subclass(type=int), 
-                                   'ps.b': NeuroTools.parameters.validators.Subclass(type=int)}, 'null': NeuroTools.parameters.validators.Subclass(type=NoneType), 'mydict': {'c': NeuroTools.parameters.validators.Subclass(type=int), 'd': NeuroTools.parameters.validators.Subclass(type=int)}, 'hello': NeuroTools.parameters.validators.Subclass(type=str)}
+                           'ps2': {'ps': {'a':NeuroTools.parameters.validators.Subclass(type=int),
+                                          'b':NeuroTools.parameters.validators.Subclass(type=int)},
+                                   'c': NeuroTools.parameters.validators.Subclass(type=int)}, 
+                           'null': NeuroTools.parameters.validators.Subclass(type=type(None)),
+                           'mydict': {'c': NeuroTools.parameters.validators.Subclass(type=int),
+                                      'd': NeuroTools.parameters.validators.Subclass(type=int)},
+                           'hello': NeuroTools.parameters.validators.Subclass(type=str)})
 
 
@@ -63 +67 @@
 
 
+    def test_validate_generated_schema(self):
+        s1 = ParameterSchema(ps3)
+
+        v = CongruencyValidator()
+        assert v.validate(ps3,s1)==True
+        
     def test_simple_validate(self):
+        v = CongruencyValidator()
+        assert v.validate(ps3,schema3)==True
+
+    def test_validation_failure_info(self):
+        """ Test the error output for an failed validation against a schema"""
+
         s1 = ParameterSchema(ps3)
-        print s1
-        #print ps3.flatten()
         
+        s1.ps2.ps.a = Subclass(type=float)
+        v = CongruencyValidator()
+        r = False
+        try:
+            r = v.validate(ps3,s1)
+        except Exception as e:
+            assert isinstance(e,ValidationError)
+            assert e.path=='ps2.ps.a'
+            assert e.parameter==ps3.ps2.ps.a
+            assert e.schema_base==s1.ps2.ps.a
+        assert r==False
 
     def test_congruent_dicts(self):