Support DataFrames in display class

Author: gnestor

jupyterlab_table/__init__.py

@@ -1,5 +1,7 @@
-from IPython.display import display, JSON
+from IPython.display import display, DisplayObject
 import json
+import pandas as pd
+from .utils import prepare_data
 
 
 # Running `npm run build` will create static resources in the static
@@ -23,22 +25,77 @@ def _jupyter_nbextension_paths():
 
 # A display class that can be used within a notebook. E.g.:
 #   from jupyterlab_table import JSONTable
-#   JSONTable(data)
+#   JSONTable(data, schema)
 
-class JSONTable(JSON):
+class JSONTable(DisplayObject):
     """A display class for displaying JSONTable visualizations in the Jupyter Notebook and IPython kernel.
     
-    JSONTable expects a JSON-able dict, not serialized JSON strings.
+    JSONTable expects a JSON-able list, not serialized JSON strings.
 
     Scalar types (None, number, string) are not allowed, only dict containers.
     """
+    # wrap data in a property, which warns about passing already-serialized JSON
+    _data = None
+    _schema = None
+    def __init__(self, data=None, schema=None, url=None, filename=None, metadata=None):
+        """Create a JSON Table display object given raw data.
 
-    def _data_and_metadata(self):
-        return self.data, self.metadata
-    
+        Parameters
+        ----------
+        data : list
+            Not an already-serialized JSON string.
+            Scalar types (None, number, string) are not allowed, only list containers.
+        schema : dict
+            JSON Table Schema. See http://frictionlessdata.io/guides/json-table-schema/.
+        url : unicode
+            A URL to download the data from.
+        filename : unicode
+            Path to a local file to load the data from.
+        metadata: dict
+            Specify extra metadata to attach to the json display object.
+        """
+        self.schema = schema
+        self.metadata = metadata
+        super(JSONTable, self).__init__(data=data, url=url, filename=filename)
+
+    def _check_data(self):
+        if self.data is not None and not isinstance(self.data, (list, pd.DataFrame)):
+            raise TypeError("%s expects a JSONable list or pandas DataFrame, not %r" % (self.__class__.__name__, self.data))
+        if self.schema is not None and not isinstance(self.schema, dict):
+            raise TypeError("%s expects a JSONable dict, not %r" % (self.__class__.__name__, self.schema))
+        
+    @property
+    def data(self):
+        return self._data
+        
+    @property
+    def schema(self):
+        return self._schema
+
+    @data.setter
+    def data(self, data):
+        if isinstance(data, str):
+            # warnings.warn("JSONTable expects JSON-able dict or list, not JSON strings")
+            data = json.loads(data)
+        self._data = data
+        
+    @schema.setter
+    def schema(self, schema):
+        if isinstance(schema, str):
+            # warnings.warn("JSONTable expects a JSON-able list, not JSON strings")
+            schema = json.loads(schema)
+        self._schema = schema
+        
     def _ipython_display_(self):
         bundle = {
-            'application/vnd.dataresource+json': self.data,
+            'application/vnd.dataresource+json': {
+                'resources': [
+                    {
+                        'schema': self.schema,
+                        'data': prepare_data(self.data)
+                    }
+                ]
+            },
             'text/plain': '<jupyterlab_table.JSONTable object>'
         }
         metadata = {

jupyterlab_table/utils.py

@@ -0,0 +1,81 @@
+import cgi
+import codecs
+import collections
+import os.path
+import pandas as pd
+
+
+def nested_update(d, u):
+    """Update nested dictionary d (in-place) with keys from u."""
+    for k, v in u.items():
+        if isinstance(v, collections.Mapping):
+            d[k] = nested_update(d.get(k, {}), v)
+        else:
+            d[k] = v
+    return d
+
+
+def abs_path(path):
+    """Make path absolute."""
+    return os.path.join(
+        os.path.dirname(os.path.abspath(__file__)),
+        path)
+
+
+def get_content(path):
+    """Get content of file."""
+    with codecs.open(abs_path(path), encoding='utf-8') as f:
+        return f.read()
+
+
+def escape(string):
+    """Escape the string."""
+    return cgi.escape(string, quote=True)
+
+
+def sanitize_dataframe(df):
+    """Sanitize a DataFrame to prepare it for serialization.
+
+    * Make a copy
+    * Raise ValueError if it has a hierarchical index.
+    * Convert categoricals to strings.
+    * Convert np.int dtypes to Python int objects
+    * Convert floats to objects and replace NaNs by None.
+    * Convert DateTime dtypes into appropriate string representations
+    """
+    import pandas as pd
+    import numpy as np
+
+    df = df.copy()
+
+    if isinstance(df.index, pd.core.index.MultiIndex):
+        raise ValueError('Hierarchical indices not supported')
+    if isinstance(df.columns, pd.core.index.MultiIndex):
+        raise ValueError('Hierarchical indices not supported')
+
+    for col_name, dtype in df.dtypes.iteritems():
+        if str(dtype) == 'category':
+            # XXXX: work around bug in to_json for categorical types
+            # https://github.com/pydata/pandas/issues/10778
+            df[col_name] = df[col_name].astype(str)
+        elif np.issubdtype(dtype, np.integer):
+            # convert integers to objects; np.int is not JSON serializable
+            df[col_name] = df[col_name].astype(object)
+        elif np.issubdtype(dtype, np.floating):
+            # For floats, convert nan->None: np.float is not JSON serializable
+            col = df[col_name].astype(object)
+            df[col_name] = col.where(col.notnull(), None)
+        elif str(dtype).startswith('datetime'):
+            # Convert datetimes to strings
+            # astype(str) will choose the appropriate resolution
+            df[col_name] = df[col_name].astype(str).replace('NaT', '')
+    return df
+
+
+def prepare_data(data=None):
+    """Prepare Plotly data from Pandas DataFrame."""
+    
+    if isinstance(data, list):
+        return data
+    data = sanitize_dataframe(data)
+    return data.to_dict(orient='records')