Add more descriptive pydeck types classes

bindings/pydeck/pydeck/bindings/json_tools.py

@@ -3,6 +3,8 @@
 """
 import json
 
+from .types import Type
+
 # Attributes to ignore during JSON serialization
 IGNORE_KEYS = [
     "mapbox_key",
@@ -60,16 +62,25 @@ def lower_camel_case_keys(attrs):
         camel_key = camel_and_lower(snake_key)
         attrs[camel_key] = attrs.pop(snake_key)
 
+    return attrs
+
 
 def default_serialize(o, remap_function=lower_camel_case_keys):
     """Default method for rendering JSON from a dictionary"""
     attrs = vars(o)
+
+    # Remove keys where value is None
     attrs = {k: v for k, v in attrs.items() if v is not None}
     for ignore_attr in IGNORE_KEYS:
         if attrs.get(ignore_attr):
             del attrs[ignore_attr]
+
+    # For each object of type pydeck.Type, call .json
+    attrs = {k: v.json() if isinstance(v, Type) else v for k, v in attrs.items()}
+
     if remap_function:
-        remap_function(attrs)
+        attrs = remap_function(attrs)
+
     return attrs
 
 

bindings/pydeck/pydeck/bindings/layer.py

@@ -1,10 +1,11 @@
 import uuid
+from collections.abc import Iterable
 
 import numpy as np
 
-from ..data_utils import is_pandas_df, has_geo_interface, records_from_geo_interface
+from ..data_utils import has_geo_interface, is_pandas_df, records_from_geo_interface
 from .json_tools import JSONMixin, camel_and_lower
-
+from .types import Function, Literal, Type
 
 TYPE_IDENTIFIER = "@@type"
 FUNCTION_IDENTIFIER = "@@="
@@ -82,28 +83,29 @@ def __init__(self, type, data, id=None, use_binary_transport=None, **kwargs):
         self._kwargs = kwargs.copy()
         if kwargs:
             for k, v in kwargs.items():
+                if isinstance(v, Type):
+                    continue
+
                 # We assume strings and arrays of strings are identifiers
                 # ["lng", "lat"] would be converted to '[lng, lat]'
                 # TODO given that data here is usually a list of records,
                 # we could probably check that the identifier is in the row
                 # Errors on case like get_position='-', however
 
                 if isinstance(v, str) and v[0] in QUOTE_CHARS and v[0] == v[-1]:
-                    # Skip quoted strings
-                    kwargs[k] = v.replace(v[0], "")
+                    # For quoted strings, consider inner part a literal string
+                    kwargs[k] = Literal(v[1:-1])
+
                 elif isinstance(v, str):
-                    # Have @deck.gl/json treat strings values as functions
-                    kwargs[k] = FUNCTION_IDENTIFIER + v
-
-                elif isinstance(v, list) and v != [] and isinstance(v[0], str):
-                    # Allows the user to pass lists e.g. to specify coordinates
-                    array_as_str = ""
-                    for i, identifier in enumerate(v):
-                        if i == len(v) - 1:
-                            array_as_str += "{}".format(identifier)
-                        else:
-                            array_as_str += "{}, ".format(identifier)
-                    kwargs[k] = "{}[{}]".format(FUNCTION_IDENTIFIER, array_as_str)
+                    # Treat strings values as functions
+                    kwargs[k] = Function(v)
+
+                elif isinstance(v, Iterable) and v != [] and isinstance(v[0], str):
+                    # Allow lists of str e.g. to specify coordinates
+                    kwargs[k] = Function(v)
+
+                else:
+                    kwargs[k] = Literal(v)
 
             self.__dict__.update(kwargs)
 

bindings/pydeck/pydeck/bindings/types.py

@@ -0,0 +1,101 @@
+import abc
+import json
+from collections.abc import Iterable
+
+TYPE_IDENTIFIER = "@@type"
+FUNCTION_IDENTIFIER = "@@="
+ENUM_IDENTIFIER = "@@#"
+
+
+class Type(metaclass=abc.ABCMeta):
+    """Base class for Pydeck defined type"""
+
+    def __init__(self, value):
+        self._value = value
+
+    def __repr__(self):
+        return self.type_name + "(" + str(self.json()) + ")"
+
+    @property
+    @abc.abstractmethod
+    def type_name(self):
+        """Name of Type; used in default __repr__"""
+
+    @abc.abstractmethod
+    def json(self):
+        """JSON representation of object for serialization"""
+
+
+class Enum(Type):
+    """Enum type
+
+    Interpret as an Enum, resolving in the JSON configuration
+    """
+
+    type_name = "Enum"
+
+    def __init__(self, value):
+        if not isinstance(value, str):
+            raise TypeError("Enum value must be a string")
+
+        super(Enum, self).__init__(value)
+
+    def json(self):
+        return ENUM_IDENTIFIER + self._value
+
+
+class Function(Type):
+    """Function type
+
+    Interpret as a function, parsing unquoted character strings as identifiers
+    """
+
+    type_name = "Function"
+
+    def json(self):
+        if isinstance(self._value, Iterable) and not isinstance(self._value, str):
+            return FUNCTION_IDENTIFIER + "[{}]".format(", ".join(map(str, self._value)))
+
+        return FUNCTION_IDENTIFIER + str(self._value)
+
+
+class Identifier(Type):
+    """Identifier type
+    """
+
+    type_name = "Identifier"
+
+    def __init__(self, value):
+        if not isinstance(value, str):
+            raise TypeError("Identifier value must be a string")
+
+        super(Identifier, self).__init__(value)
+
+    def __str__(self):
+        return str(self._value)
+
+    def json(self):
+        return self._value
+
+
+class Literal(Type):
+    """A Literal object
+
+    Can be any JSON-encodable object
+    """
+
+    type_name = "Literal"
+
+    def __init__(self, value):
+        try:
+            json.dumps(value)
+        except TypeError as e:
+            raise TypeError("Literal value must be JSON serializable\n" + e)
+
+        super(Literal, self).__init__(value)
+
+    def __str__(self):
+        return '"{}"'.format(self._value)
+
+    def json(self):
+        return self._value