Merge pull request #6 from gnestor/develop

0.17.0

Author: gnestor

.cookiecutter.yaml

@@ -0,0 +1,7 @@
+default_context:
+    author_name: "Grant Nestor"
+    author_email: "grantnestor@gmail.com"
+    mime_type: "application/vnd.dataresource+json"
+    file_extension: "table.json"
+    mime_short_name: "JSONTable"
+    extension_name: "jupyterlab_table"

README.md

@@ -6,7 +6,7 @@ A JupyterLab and Jupyter Notebook extension for rendering [JSON Table Schema](ht
 
 ## Prerequisites
 
-* JupyterLab ^0.16.0 and/or Notebook >=4.3.0
+* JupyterLab ^0.17.0 and/or Notebook >=4.3.0
 
 ## Usage
 

RELEASE.md

@@ -4,23 +4,24 @@ This document guides an extension maintainer through creating and publishing a r
 
 ## Update version number
 
-Update the version number in `setup.py` and in `package.json`.
+Update the version number in `setup.py`, `labextension/package.json`, and `nbextension/package.json`.
+
+Commit your changes, add git tag for this version, and push both commit and tag to your origin/remote repo.
 
 ## Remove generated files
 
-Remove old Javascript bundle builds and delete the `dist/` folder to remove old Python package builds:
+Remove old Javascript bundle and Python package builds:
 
 ```bash
-npm run clean
-rm -rf dist/
+git clean -xfd
 ```
 
 ## Build the package
 
 Build the Javascript extension bundle, then build the Python package and wheel:
 
 ```bash
-npm run build
+bash build.js
 python setup.py sdist
 python setup.py bdist_wheel --universal
 ```

component/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "react-json-table",
+  "name": "jupyterlab_table_react",
   "version": "1.0.0",
   "description": "A React component for rendering JSON schema table",
   "main": "index.js",

jupyterlab_table/README.md

@@ -5,4 +5,4 @@ Single Python package for lab and notebook extensions
 ## Structure
 
 * `static`: Built Javascript from `../labextension/` and `../nbextension/`
-* `__init__.py`: Exports paths for lab and notebook extensions and optional display method
+* `__init__.py`: Exports paths and metadata of lab and notebook extensions and exports an optional `display` method that can be imported into a notebook and used to easily display data using this renderer

jupyterlab_table/__init__.py

@@ -1,6 +1,7 @@
-from IPython.display import display
-import pandas as pd
+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
@@ -22,28 +23,82 @@ def _jupyter_nbextension_paths():
     }]
 
 
-# A display function that can be used within a notebook. E.g.:
+# A display class that can be used within a notebook. E.g.:
 #   from jupyterlab_table import JSONTable
-#   JSONTable(data)
-
-def JSONTable(data, schema=None):
-    if isinstance(data, pd.DataFrame):
-        # hack until pandas supports `df.to_json(orient='json_table_schema')`
-        # https://github.com/pandas-dev/pandas/pull/14904
-        text = data.to_csv()
-        data = [data.loc[i].to_dict() for i in data.index]
-    else:
-        text = json.dumps(data, indent=4)
-    bundle = {
-        'application/vnd.dataresource+json': {
-            'resources': [
-                {
-                    'schema': schema,
-                    'data': data
-                }
-            ]
-        },
-        'application/json': data,
-        'text/plain': text
-    }
-    display(bundle, raw=True)
+#   JSONTable(data, schema)
+    
+class JSONTable(DisplayObject):
+    """A display class for displaying JSONTable visualizations in the Jupyter Notebook and IPython kernel.
+    
+    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.
+
+        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': {
+                'resources': [
+                    {
+                        'schema': self.schema,
+                        'data': prepare_data(self.data)
+                    }
+                ]
+            },
+            'text/plain': '<jupyterlab_table.JSONTable object>'
+        }
+        metadata = {
+            'application/vnd.dataresource+json': self.metadata
+        }
+        display(bundle, metadata=metadata, raw=True) 

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')

labextension/README.md

@@ -4,9 +4,7 @@ A JupyterLab extension for rendering JSON Table Schema
 
 ## Prerequisites
 
-* `jupyterlab>=0.11`
-
-![file renderer](http://g.recordit.co/cbf0xnQHKn.gif)
+* `jupyterlab@^0.17.0`
 
 ## Development
 

labextension/build_extension.js

@@ -3,26 +3,45 @@ var path = require('path');
 
 buildExtension({
   name: 'jupyterlab_table',
-  entry: './src/plugin.js',
-  outputDir: '../jupyterlab_table/static',
+  entry: path.join(__dirname, 'src', 'plugin.js'),
+  outputDir: path.join(
+    __dirname,
+    '..',
+    'jupyterlab_table',
+    'static'
+  ),
   useDefaultLoaders: false,
   config: {
     module: {
       loaders: [
         { test: /\.html$/, loader: 'file-loader' },
         { test: /\.(jpg|png|gif)$/, loader: 'file-loader' },
-        { test: /\.woff2(\?v=\d+\.\d+\.\d+)?$/, loader: 'url-loader?limit=10000&mimetype=application/font-woff' },
-        { test: /\.woff(\?v=\d+\.\d+\.\d+)?$/, loader: 'url-loader?limit=10000&mimetype=application/font-woff' },
-        { test: /\.ttf(\?v=\d+\.\d+\.\d+)?$/, loader: 'url-loader?limit=10000&mimetype=application/octet-stream' },
+        {
+          test: /\.woff2(\?v=\d+\.\d+\.\d+)?$/,
+          loader: 'url-loader?limit=10000&mimetype=application/font-woff'
+        },
+        {
+          test: /\.woff(\?v=\d+\.\d+\.\d+)?$/,
+          loader: 'url-loader?limit=10000&mimetype=application/font-woff'
+        },
+        {
+          test: /\.ttf(\?v=\d+\.\d+\.\d+)?$/,
+          loader: 'url-loader?limit=10000&mimetype=application/octet-stream'
+        },
         { test: /\.eot(\?v=\d+\.\d+\.\d+)?$/, loader: 'file-loader' },
-        { test: /\.svg(\?v=\d+\.\d+\.\d+)?$/, loader: 'url-loader?limit=10000&mimetype=image/svg+xml' },
+        {
+          test: /\.svg(\?v=\d+\.\d+\.\d+)?$/,
+          loader: 'url-loader?limit=10000&mimetype=image/svg+xml'
+        },
         { test: /\.json$/, loader: 'json-loader' },
-        { test: /\.js$/,
-          exclude: /node_modules(?!\/react-json-table)/, 
+        {
+          test: /\.js$/,
+          include: [
+            path.join(__dirname, 'src'),
+            path.join(__dirname, 'node_modules', 'jupyterlab_table_react')
+          ],
           loader: 'babel-loader',
-          query: {
-            presets: ['latest', 'stage-0', 'react']
-          }
+          query: { presets: [ 'latest', 'stage-0', 'react' ] }
         }
       ]
     }

labextension/package.json

@@ -1,9 +1,9 @@
 {
   "private": true,
   "name": "jupyterlab_table_labextension",
-  "version": "0.16.0",
+  "version": "0.17.0",
+  "author": "Grant Nestor <grantnestor@gmail.com>",
   "description": "A JupyterLab extension for rendering JSON Table Schema",
-  "author": "Grant Nestor",
   "main": "lib/plugin.js",
   "keywords": [
     "jupyter",
@@ -12,7 +12,7 @@
   ],
   "scripts": {
     "build": "node build_extension.js",
-    "watch": "watch \"npm install\" src ../component --wait 15 --ignoreDotFiles",
+    "watch": "watch \"npm install\" src ../component --wait 10 --ignoreDotFiles",
     "preinstall": "npm install ../component",
     "prepublish": "npm run build",
     "extension:install": "jupyter labextension install --symlink --py --sys-prefix jupyterlab_table",
@@ -21,20 +21,19 @@
     "extension:disable": "jupyter labextension disable --py --sys-prefix jupyterlab_table"
   },
   "dependencies": {
-    "jupyterlab": "^0.16.0",
-    "phosphor": "^0.7.0",
+    "jupyterlab": "^0.17.0",
+    "@phosphor/algorithm": "^0.1.0",
+    "@phosphor/widgets": "^0.1.3",
     "react": "^15.3.2",
     "react-dom": "^15.3.2"
   },
   "devDependencies": {
     "@jupyterlab/extension-builder": ">=0.10.0",
-    "@jupyterlab/services": ">=0.25.0",
     "babel-core": "^6.18.2",
     "babel-loader": "^6.2.7",
     "babel-preset-latest": "^6.16.0",
     "babel-preset-react": "^6.16.0",
     "babel-preset-stage-0": "^6.16.0",
-    "rimraf": "^2.5.4",
     "watch": "^1.0.1"
   }
 }