Merge tag '0.0.20' into develop

Version 0.0.20

+ Adds support for `oneOf` in array `items` definitions
    + This the the pattern where an array can have multiple differnt
      types, but from a restricted set. Required setting up a TypeProxy
      object to validate array types.

+ Fixes bug #39 where array item references weren't resolved generally. h/t @blr246

Author: cwacek

python_jsonschema_objects/classbuilder.py

@@ -288,6 +288,34 @@ def MakeLiteral(name, typ, value, **properties):
       return klass(value)
 
 
+class TypeProxy(object):
+
+    def __init__(self, types):
+        self._types = types
+
+    def __call__(self, *a, **kw):
+        validation_errors = []
+        valid_types = self._types
+        for klass in valid_types:
+            logger.debug(util.lazy_format(
+                "Attempting to instantiate {0} as {1}",
+                self.__class__, klass))
+            try:
+                obj = klass(*a, **kw)
+            except TypeError as e:
+                validation_errors.append((klass, e))
+            except validators.ValidationError as e:
+                validation_errors.append((klass, e))
+            else:
+                return obj
+
+        else:  # We got nothing
+            raise validators.ValidationError(
+                "Unable to instantiate any valid types: \n"
+                "\n".join("{0}: {1}".format(k, e) for k, e in validation_errors)
+            )
+
+
 class LiteralValue(object):
   """Docstring for LiteralValue """
 
@@ -426,7 +454,7 @@ def _construct(self, uri, clsdata, parent=(ProtocolBase,)):
 
                 with self.resolver.resolving(uri) as resolved:
                     self.resolved[uri] = None # Set incase there is a circular reference in schema definition
-                    self.resolved[uri] = self._build_object(
+                    self.resolved[uri] = self.construct(
                         uri,
                         resolved,
                         parent)
@@ -552,7 +580,19 @@ def _build_object(self, nm, clsdata, parents):
                         uri = "{0}/{1}_{2}".format(nm,
                                                    prop, "<anonymous_field>")
                         try:
-                            typ = self.construct(uri, detail['items'])
+                            if 'oneOf' in detail['items']:
+                                typ = TypeProxy([
+                                    self.construct(uri + "_%s" % i, item_detail)
+                                    if '$ref' not in item_detail else
+                                    self.construct(util.resolve_ref_uri(
+                                        self.resolver.resolution_scope,
+                                        item_detail['$ref']),
+                                        item_detail)
+
+                                    for i, item_detail in enumerate(detail['items']['oneOf'])]
+                                    )
+                            else:
+                                typ = self.construct(uri, detail['items'])
                             propdata = {'type': 'array',
                                         'validator': validators.ArrayValidator.create(uri, item_constraint=typ,
                                                                                 addl_constraints=detail)}

python_jsonschema_objects/util.py

@@ -12,7 +12,7 @@ def __init__(self, fmt, *args, **kwargs):
         self.kwargs = kwargs
 
     def __str__(self):
-        self.fmt.format(*self.args, **self.kwargs)
+        return self.fmt.format(*self.args, **self.kwargs)
 
 
 def safe_issubclass(x, y):

python_jsonschema_objects/validators.py

@@ -1,5 +1,6 @@
 import six
 from python_jsonschema_objects import util
+import collections
 
 
 class ValidationError(Exception):
@@ -218,9 +219,13 @@ def validate_items(self):
             elif util.safe_issubclass(typ, classbuilder.ProtocolBase):
                 if not isinstance(elem, typ):
                     try:
-                      val = typ(**util.coerce_for_expansion(elem))
+                        if isinstance(elem, (six.string_types, six.integer_types, float)):
+                            val = typ(elem)
+                        else:
+                            val = typ(**util.coerce_for_expansion(elem))
                     except TypeError as e:
-                      raise ValidationError("'{0}' is not a valid value for '{1}'".format(elem, typ))
+                        raise ValidationError("'{0}' is not a valid value for '{1}': {2}"
+                                              .format(elem, typ, e))
                 else:
                     val = elem
                 val.validate()
@@ -229,6 +234,17 @@ def validate_items(self):
                 val = typ(elem)
                 val.validate()
                 typed_elems.append(val)
+            elif isinstance(typ, classbuilder.TypeProxy):
+                try:
+                    if isinstance(elem, (six.string_types, six.integer_types, float)):
+                        val = typ(elem)
+                    else:
+                        val = typ(**util.coerce_for_expansion(elem))
+                except TypeError as e:
+                    raise ValidationError("'{0}' is not a valid value for '{1}': {2}"
+                                          .format(elem, typ, e))
+                val.validate()
+                typed_elems.append(val)
 
         return typed_elems
 
@@ -257,6 +273,8 @@ def create(name, item_constraint=None, **addl_constraints):
                     if not any([isdict, isklass]):
                         raise TypeError(
                             "Item constraint (position {0}) is not a schema".format(i))
+            elif isinstance(item_constraint, classbuilder.TypeProxy):
+                pass
             else:
                 isdict = isinstance(item_constraint, (dict,))
                 isklass = isinstance( item_constraint, type) and util.safe_issubclass(

test/test_pytest.py

@@ -20,6 +20,62 @@ def test_regression_9():
     builder = pjs.ObjectBuilder(schema)
     builder.build_classes()
 
+def test_arrays_can_have_reffed_items_of_mixed_type():
+    schema = {
+            "$schema": "http://json-schema.org/schema#",
+            "id": "test",
+            "type": "object",
+            "properties": {
+                "list": {
+                    "type": "array",
+                    "items": {"oneOf": [
+                        {"$ref": "#/definitions/foo"},
+                        {
+                            "type": "object",
+                            "properties": {
+                                "bar": {"type":"string"}
+                                },
+                            "required": ["bar"]
+                        }
+                        ]},
+                    }
+                },
+            "definitions": {
+                "foo": {
+                    "type": "string"
+                    }
+                }
+            }
+    builder = pjs.ObjectBuilder(schema)
+    ns = builder.build_classes()
+
+    ns.Test(list=["foo", "bar"])
+    ns.Test(list=[{"bar": "nice"}, "bar"])
+    with pytest.raises(pjs.ValidationError):
+        ns.Test(list=[100])
+
+
+def test_regression_39():
+    builder = pjs.ObjectBuilder("test/thing-two.json")
+    ns = builder.build_classes()
+
+    for thing in ('BarMessage', 'BarGroup', "Bar", "Header"):
+        assert thing in ns
+
+    x = ns.BarMessage(id="message_id",
+                      title="my bar group",
+                      bars=[{"name": "Freddies Half Shell"}]
+                      )
+
+    x.validate()
+
+    # Now an invalid one 
+    with pytest.raises(pjs.ValidationError):
+        ns.BarMessage(id="message_id",
+                      title="my bar group",
+                      bars=[{"Address": "I should have a name"}]
+                      )
+
 
 def test_loads_markdown_schema_extraction(markdown_examples):
     assert 'Other' in markdown_examples

test/thing-one.json

@@ -0,0 +1,36 @@
+{
+  "$schema": "http://json-schema.org/schema#",
+  "id": "thing_one",
+  "title": "thing_one",
+  "description": "The first thing.",
+  "type": "object",
+  "definitions": {
+    "bar": {
+      "description": "a bar",
+      "properties": {
+        "name": {
+          "description": "unique name for bar",
+          "type": "string",
+          "example": "awesome-bar"
+        }
+      },
+      "required": ["name"]
+    },
+    "bar_group": {
+      "description": "a group of bars",
+      "properties": {
+        "title": {
+          "description": "group title",
+          "type": "string"
+        },
+        "bars": {
+          "description": "list of bars",
+          "type": "array",
+          "items": {
+            "$ref": "file:///thing-one.json#/definitions/bar"
+          }
+        }
+      }
+    }
+  }
+}

test/thing-two.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "http://json-schema.org/schema#",
+  "id": "thing_two",
+  "title": "thing_two",
+  "description": "The second thing.",
+  "type": "object",
+  "properties": {
+    "message": {"$ref": "#/definitions/bar_message"}
+  },
+  "definitions": {
+    "header": {
+      "description": "a message header",
+      "properties": {
+        "id": {
+          "description": "message id",
+          "type": "string"
+        }
+      }
+    },
+    "bar_message": {
+      "description": "a bar message",
+      "allOf": [
+        {"$ref": "file:///thing-two.json#/definitions/header"},
+        {"$ref": "file:///thing-one.json#/definitions/bar_group"}
+      ]
+    }
+  }
+}