JSON serialization and schema generation

param/parameterized.py

@@ -10,6 +10,7 @@
 import random
 import numbers
 import operator
+from .serializer import JSONSerialization
 
 from collections import defaultdict, namedtuple, OrderedDict
 from operator import itemgetter,attrgetter
@@ -687,6 +688,8 @@ class Foo(Bar):
     # class is created, owner, name, and _internal_name are
     # set.
 
+    _serializer = JSONSerialization
+
     def __init__(self,default=None,doc=None,label=None,precedence=None,  # pylint: disable-msg=R0913
                  instantiate=False,constant=False,readonly=False,
                  pickle_default_value=True, allow_None=False,
@@ -731,6 +734,15 @@ class hierarchy (see ParameterizedMetaclass).
         self.per_instance = per_instance
 
 
+    def _serialize(self, value):
+        return JSONSerialization.serialize(self.__class__.__name__, value)
+
+    def _deserialize(self, string):
+        return JSONSerialization.deserialize(self.__class__.__name__, string)
+
+    def _schema(self, safe=False):
+        return JSONSerialization.parameter_schema(self.__class__.__name__, self, safe=safe)
+
     @property
     def label(self):
         if self.name and self._label is None:
@@ -1566,6 +1578,14 @@ class or instance that contains an iterable collection of
             for obj in sublist:
                 obj.param.set_dynamic_time_fn(time_fn,sublistattr)
 
+    def serialize_parameters(self_):
+        self_or_cls = self_.self_or_cls
+        return Parameter._serializer.serialize_parameters(self_or_cls)
+
+    def schema(self_, safe=False):
+        self_or_cls = self_.self_or_cls
+        return Parameter._serializer.schema(self_or_cls, safe=safe)
+
     def get_param_values(self_,onlychanged=False):
         """
         Return a list of name,value pairs for all Parameters of this

param/serializer.py

@@ -0,0 +1,178 @@
+"""
+Classes used to support string serialization of Parameters and
+Parameterized objects.
+"""
+
+import json
+import datetime as dt
+
+class UnserializableException(Exception):
+    pass
+
+class UnsafeserializableException(Exception):
+    pass
+
+def JSONNullable(json_type):
+    "Express a JSON schema type as nullable to easily support Parameters that allow_None"
+    return { "anyOf": [ json_type, { "type": "null"}] }
+
+
+
+class Serialization(object):
+    """
+    Base class used to implement different types of serialization.
+    """
+
+    @classmethod
+    def schema(cls, pobj):
+        raise NotImplementedError
+
+    @classmethod
+    def serialize_parameters(cls, pobj):
+        raise NotImplementedError
+
+
+
+class JSONSerialization(Serialization):
+    """
+    Class responsible for specifying JSON serialization, deserialization
+    and JSON schemas for Parameters and Parameterized classes and
+    objects.
+    """
+
+    unserializable_parameter_types = ['Callable']
+
+    json_schema_literal_types = {int:'integer', float:'number', str:'string'}
+
+
+    @classmethod
+    def schema(cls, pobj, safe=False):
+        schema = {}
+        for name, p in pobj.param.objects('existing').items():
+            schema[name] = p._schema(safe=safe)
+            if p.doc:
+                schema[name]["description"] = p.doc.strip()
+        return schema
+
+    @classmethod
+    def serialize_parameters(cls, pobj):
+        components = {}
+        for name, p in pobj.param.objects('existing').items():
+            value = pobj.param.get_value_generator(name)
+            components[name] = p._serialize(value)
+
+        contents = ', '.join('"%s":%s' % (name, sval) for name, sval in components.items())
+        return '{{{contents}}}'.format(contents=contents)
+
+    # Parameter level methods
+
+    @classmethod
+    def _get_method(cls, ptype, suffix):
+        "Returns specialized method if available, otherwise None"
+        method_name = ptype.lower()+'_' + suffix
+        return getattr(cls, method_name, None)
+
+    @classmethod
+    def parameter_schema(cls, ptype, p, safe=False):
+        if ptype in cls.unserializable_parameter_types:
+            raise UnserializableException
+        dispatch_method = cls._get_method(ptype, 'schema')
+        if dispatch_method:
+            return dispatch_method(p, safe=safe)
+        else:
+            return { "type": ptype.lower()}
+
+    @classmethod
+    def serialize(cls, ptype, value):
+        dispatch_method = cls._get_method(ptype, 'serialize')
+        if dispatch_method:
+            return dispatch_method(value)
+        else:
+            return json.dumps(value)
+
+    @classmethod
+    def deserialize(cls, ptype, string):
+        dispatch_method = cls._get_method(ptype, 'deserialize')
+        if dispatch_method:
+            return dispatch_method(string)
+        else:
+            return json.loads(string)
+
+    # Custom Serializers
+
+    @classmethod
+    def date_serialize(cls, value):
+        string = value.replace(microsecond=0).isoformat() # Test *with* microseconds.
+        return json.dumps(string)
+
+    # Custom Deserializers
+
+    @classmethod
+    def date_deserialize(cls, string):
+        return dt.datetime.fromisoformat(string)  # FIX: 3.7+ only
+
+    @classmethod
+    def tuple_deserialize(cls, string):
+        return tuple(json.loads(string))
+
+    # Custom Schemas
+
+    @classmethod
+    def date_schema(cls, p, safe=False):
+        return { "type": "string", "format": "date-time"}
+
+    @classmethod
+    def tuple_schema(cls, p, safe=False):
+        return { "type": "array"}
+
+    @classmethod
+    def number_schema(cls, p, safe=False):
+        schema = { "type": p.__class__.__name__.lower() }
+        if p.bounds is not None:
+            (low, high) = p.bounds
+            if low is not None:
+                key = 'minimum' if p.inclusive_bounds[0] else 'exclusiveMinimum'
+                schema[key] = low
+            if high is not None:
+                key = 'maximum' if p.inclusive_bounds[0] else 'exclusiveMaximum'
+                schema[key] = high
+
+        return JSONNullable(schema) if p.allow_None else schema
+
+    @classmethod
+    def integer_schema(cls, p, safe=False):
+        return cls.number_schema(p)
+
+    @classmethod
+    def numerictuple_schema(cls, p, safe=False):
+        return {"type": "array",
+                "additionalItems": { "type": "number" }}
+
+    @classmethod
+    def xycoordinates_schema(cls, p, safe=False):
+        return  {
+            "type": "array",
+            "items": [
+                {"type": "number"}, {"type": "number"}],
+            "additionalItems": False
+        }
+
+    @classmethod
+    def range_schema(cls, p, safe=False):
+        # Extend for allow None
+        return  {
+            "type": "array",
+            "items": [{"type": "number"},{"type": "number"}],
+            #"additionalItems": "false"
+        }
+
+    @classmethod
+    def list_schema(cls, p, safe=False):
+        schema =  { "type": "array"}
+        if safe is True and p.class_ is None:
+            msg = ('List without a class specified cannot be guaranteed '
+                   'to be safe for serialization')
+            raise UnsafeserializableException(msg)
+        if p.class_ is not None and p.class_ in cls.json_schema_literal_types:
+            schema['items'] = {"type": cls.json_schema_literal_types[p.class_]}
+        return schema