Merge pull request #165 from plotly/json-encoder-tweaks

Json encoder tweaks

Author: theengineear

plotly/grid_objs/grid_objs.py

@@ -67,7 +67,7 @@ def __init__(self, data, name):
 
     def __str__(self):
         max_chars = 10
-        jdata = json.dumps(self.data, cls=utils._plotlyJSONEncoder)
+        jdata = json.dumps(self.data, cls=utils.PlotlyJSONEncoder)
         if len(jdata) > max_chars:
             data_string = jdata[:max_chars] + "...]"
         else:

plotly/plotly/plotly.py

@@ -536,7 +536,7 @@ def write(self, trace, layout=None, validate=True,
             stream_object.update(dict(layout=layout))
 
         # TODO: allow string version of this?
-        jdata = json.dumps(stream_object, cls=utils._plotlyJSONEncoder)
+        jdata = json.dumps(stream_object, cls=utils.PlotlyJSONEncoder)
         jdata += "\n"
 
         try:
@@ -602,7 +602,7 @@ def get(figure_or_data, format='png', width=None, height=None):
 
         url = get_config()['plotly_domain'] + "/apigenimage/"
         res = requests.post(
-            url, data=json.dumps(payload, cls=utils._plotlyJSONEncoder),
+            url, data=json.dumps(payload, cls=utils.PlotlyJSONEncoder),
             headers=headers, verify=get_config()['plotly_ssl_verification']
         )
 
@@ -824,7 +824,7 @@ def upload(cls, grid, filename,
 
         payload = {
             'filename': filename,
-            'data': json.dumps(grid_json, cls=utils._plotlyJSONEncoder),
+            'data': json.dumps(grid_json, cls=utils.PlotlyJSONEncoder),
             'world_readable': world_readable
         }
 
@@ -905,7 +905,7 @@ def append_columns(cls, columns, grid=None, grid_url=None):
             raise exceptions.InputError(err)
 
         payload = {
-            'cols': json.dumps(columns, cls=utils._plotlyJSONEncoder)
+            'cols': json.dumps(columns, cls=utils.PlotlyJSONEncoder)
         }
 
         api_url = _api_v2.api_url('grids')+'/{grid_id}/col'.format(grid_id=grid_id)
@@ -980,7 +980,7 @@ def append_rows(cls, rows, grid=None, grid_url=None):
                                 'column' if n_columns == 1 else 'columns'))
 
         payload = {
-            'rows': json.dumps(rows, cls=utils._plotlyJSONEncoder)
+            'rows': json.dumps(rows, cls=utils.PlotlyJSONEncoder)
         }
 
         api_url = (_api_v2.api_url('grids')+
@@ -1098,7 +1098,7 @@ def upload(cls, meta, grid=None, grid_url=None):
         grid_id = _api_v2.parse_grid_id_args(grid, grid_url)
 
         payload = {
-            'metadata': json.dumps(meta, cls=utils._plotlyJSONEncoder)
+            'metadata': json.dumps(meta, cls=utils.PlotlyJSONEncoder)
         }
 
         api_url = _api_v2.api_url('grids')+'/{grid_id}'.format(grid_id=grid_id)
@@ -1206,14 +1206,14 @@ def _send_to_plotly(figure, **plot_options):
     """
     fig = tools._replace_newline(figure)  # does not mutate figure
     data = json.dumps(fig['data'] if 'data' in fig else [],
-                      cls=utils._plotlyJSONEncoder)
+                      cls=utils.PlotlyJSONEncoder)
     username, api_key = _get_session_username_and_key()
     kwargs = json.dumps(dict(filename=plot_options['filename'],
                              fileopt=plot_options['fileopt'],
                              world_readable=plot_options['world_readable'],
                              layout=fig['layout'] if 'layout' in fig
                              else {}),
-                        cls=utils._plotlyJSONEncoder)
+                        cls=utils.PlotlyJSONEncoder)
 
 
     payload = dict(platform='python', # TODO: It'd be cool to expose the platform for RaspPi and others

plotly/tests/test_optional/test_utils/__init__.py

@@ -0,0 +1,3 @@
+def setup_package():
+    import warnings
+    warnings.filterwarnings('ignore')

plotly/tests/test_optional/test_utils/test_utils.py

@@ -2,6 +2,10 @@
 from nose import with_setup
 from nose.plugins.attrib import attr
 
+from unittest import TestCase
+
+import math
+import pytz
 from datetime import datetime as dt
 import datetime
 import numpy as np
@@ -16,6 +20,130 @@
 from plotly.matplotlylib import Exporter, PlotlyRenderer
 from plotly.plotly import plot
 
+
+class TestJSONEncoder(TestCase):
+
+    def test_encode_as_plotly(self):
+
+        # should *fail* when object doesn't have `to_plotly_json` attribute
+        objs_without_attr = [
+            1, 'one', {'a', 'set'}, {'a': 'dict'}, ['a', 'list']
+        ]
+        for obj in objs_without_attr:
+            self.assertRaises(utils.NotEncodable,
+                              utils.PlotlyJSONEncoder.encode_as_plotly, obj)
+
+        # should return without exception when obj has `to_plotly_josn` attr
+        expected_res = 'wedidit'
+
+        class ObjWithAttr(object):
+
+            def to_plotly_json(self):
+                return expected_res
+
+        res = utils.PlotlyJSONEncoder.encode_as_plotly(ObjWithAttr())
+        self.assertEqual(res, expected_res)
+
+    def test_encode_as_list(self):
+
+        # should *fail* when object doesn't have `tolist` method
+        objs_without_attr = [
+            1, 'one', {'a', 'set'}, {'a': 'dict'}, ['a', 'list']
+        ]
+        for obj in objs_without_attr:
+            self.assertRaises(utils.NotEncodable,
+                              utils.PlotlyJSONEncoder.encode_as_list, obj)
+
+        # should return without exception when obj has `tolist` attr
+        expected_res = ['some', 'list']
+
+        class ObjWithAttr(object):
+
+            def tolist(self):
+                return expected_res
+
+        res = utils.PlotlyJSONEncoder.encode_as_list(ObjWithAttr())
+        self.assertEqual(res, expected_res)
+
+    def test_encode_as_pandas(self):
+
+        # should *fail* on things that are not specific pandas objects
+        not_pandas = ['giraffe', 6, float('nan'), ['a', 'list']]
+        for obj in not_pandas:
+            self.assertRaises(utils.NotEncodable,
+                              utils.PlotlyJSONEncoder.encode_as_pandas, obj)
+
+        # should succeed when we've got specific pandas thingies
+        res = utils.PlotlyJSONEncoder.encode_as_pandas(pd.NaT)
+        self.assertIs(res, None)
+
+    def test_encode_as_numpy(self):
+
+        # should *fail* on non-numpy-y things
+        not_numpy = ['hippo', 8, float('nan'), {'a': 'dict'}]
+        for obj in not_numpy:
+            self.assertRaises(utils.NotEncodable,
+                              utils.PlotlyJSONEncoder.encode_as_numpy, obj)
+
+        # should succeed with numpy-y-thingies
+        res = utils.PlotlyJSONEncoder.encode_as_numpy(np.ma.core.masked)
+        self.assertTrue(math.isnan(res))
+
+    def test_encode_as_datetime(self):
+
+        # should *fail* without 'utcoffset' and 'isoformat' and '__sub__' attrs
+        non_datetimes = [datetime.date(2013, 10, 1), 'noon', 56, '00:00:00']
+        for obj in non_datetimes:
+            self.assertRaises(utils.NotEncodable,
+                              utils.PlotlyJSONEncoder.encode_as_datetime, obj)
+
+        # should succeed with 'utcoffset', 'isoformat' and '__sub__' attrs
+        res = utils.PlotlyJSONEncoder.encode_as_datetime(
+            datetime.datetime(2013, 10, 1)
+        )
+        self.assertEqual(res, '2013-10-01')
+
+        # should not include extraneous microsecond info if DNE
+        res = utils.PlotlyJSONEncoder.encode_as_datetime(
+            datetime.datetime(2013, 10, 1, microsecond=0)
+        )
+        self.assertEqual(res, '2013-10-01')
+
+        # should include microsecond info if present
+        res = utils.PlotlyJSONEncoder.encode_as_datetime(
+            datetime.datetime(2013, 10, 1, microsecond=10)
+        )
+        self.assertEqual(res, '2013-10-01 00:00:00.000010')
+
+        # should convert tzinfo to utc. Note that in october, we're in EDT!
+        # therefore the 4 hour difference is correct.
+        naive_datetime = datetime.datetime(2013, 10, 1)
+        aware_datetime = pytz.timezone('US/Eastern').localize(naive_datetime)
+
+        res = utils.PlotlyJSONEncoder.encode_as_datetime(aware_datetime)
+        self.assertEqual(res, '2013-10-01 04:00:00')
+
+    def test_encode_as_date(self):
+
+        # should *fail* without 'utcoffset' and 'isoformat' and '__sub__' attrs
+        non_datetimes = ['noon', 56, '00:00:00']
+        for obj in non_datetimes:
+            self.assertRaises(utils.NotEncodable,
+                              utils.PlotlyJSONEncoder.encode_as_date, obj)
+
+        # should work with a date
+        a_date = datetime.date(2013, 10, 01)
+        res = utils.PlotlyJSONEncoder.encode_as_date(a_date)
+        self.assertEqual(res, '2013-10-01')
+
+        # should also work with a date time without a utc offset!
+        # TODO: is this OK? We could raise errors after checking isinstance...
+        res = utils.PlotlyJSONEncoder.encode_as_date(
+            datetime.datetime(2013, 10, 1, microsecond=10)
+        )
+        self.assertEqual(res, '2013-10-01 00:00:00.000010')
+
+
 ## JSON encoding
 numeric_list = [1, 2, 3]
 np_list = np.array([1, 2, 3, np.NaN, np.NAN, np.Inf, dt(2014, 1, 5)])
@@ -38,7 +166,7 @@ def test_column_json_encoding():
         Column(np_list, 'col 3')
     ]
     json_columns = json.dumps(
-        columns, cls=utils._plotlyJSONEncoder, sort_keys=True
+        columns, cls=utils.PlotlyJSONEncoder, sort_keys=True
     )
     assert('[{"data": [1, 2, 3], "name": "col 1"}, '
            '{"data": [1, "A", "2014-01-05", '
@@ -56,8 +184,8 @@ def test_figure_json_encoding():
     data = Data([s1, s2])
     figure = Figure(data=data)
 
-    js1 = json.dumps(s1, cls=utils._plotlyJSONEncoder, sort_keys=True)
-    js2 = json.dumps(s2, cls=utils._plotlyJSONEncoder, sort_keys=True)
+    js1 = json.dumps(s1, cls=utils.PlotlyJSONEncoder, sort_keys=True)
+    js2 = json.dumps(s2, cls=utils.PlotlyJSONEncoder, sort_keys=True)
 
     assert(js1 == '{"type": "scatter3d", "x": [1, 2, 3], '
                   '"y": [1, 2, 3, NaN, NaN, Infinity, "2014-01-05"], '
@@ -66,8 +194,8 @@ def test_figure_json_encoding():
     assert(js2 == '{"type": "scatter", "x": [1, 2, 3]}')
 
     # Test JSON encoding works
-    json.dumps(data, cls=utils._plotlyJSONEncoder, sort_keys=True)
-    json.dumps(figure, cls=utils._plotlyJSONEncoder, sort_keys=True)
+    json.dumps(data, cls=utils.PlotlyJSONEncoder, sort_keys=True)
+    json.dumps(figure, cls=utils.PlotlyJSONEncoder, sort_keys=True)
 
     # Test data wasn't mutated
     assert(bool(np.asarray(np_list ==
@@ -79,47 +207,48 @@ def test_figure_json_encoding():
 
 
 def test_datetime_json_encoding():
-    j1 = json.dumps(dt_list, cls=utils._plotlyJSONEncoder)
+    j1 = json.dumps(dt_list, cls=utils.PlotlyJSONEncoder)
     assert(j1 == '["2014-01-05", '
                  '"2014-01-05 01:01:01", '
                  '"2014-01-05 01:01:01.000001"]')
-    j2 = json.dumps({"x": dt_list}, cls=utils._plotlyJSONEncoder)
+    j2 = json.dumps({"x": dt_list}, cls=utils.PlotlyJSONEncoder)
     assert(j2 == '{"x": ["2014-01-05", '
                  '"2014-01-05 01:01:01", '
                  '"2014-01-05 01:01:01.000001"]}')
 
 
 def test_pandas_json_encoding():
-    j1 = json.dumps(df['col 1'], cls=utils._plotlyJSONEncoder)
+    j1 = json.dumps(df['col 1'], cls=utils.PlotlyJSONEncoder)
     assert(j1 == '[1, 2, 3, "2014-01-05", null, NaN, Infinity]')
 
     # Test that data wasn't mutated
     assert_series_equal(df['col 1'],
                         pd.Series([1, 2, 3, dt(2014, 1, 5),
                                    pd.NaT, np.NaN, np.Inf]))
 
-    j2 = json.dumps(df.index, cls=utils._plotlyJSONEncoder)
+    j2 = json.dumps(df.index, cls=utils.PlotlyJSONEncoder)
     assert(j2 == '[0, 1, 2, 3, 4, 5, 6]')
 
     nat = [pd.NaT]
-    j3 = json.dumps(nat, cls=utils._plotlyJSONEncoder)
+    j3 = json.dumps(nat, cls=utils.PlotlyJSONEncoder)
     assert(j3 == '[null]')
     assert(nat[0] is pd.NaT)
 
-    j4 = json.dumps(rng, cls=utils._plotlyJSONEncoder)
+    j4 = json.dumps(rng, cls=utils.PlotlyJSONEncoder)
     assert(j4 == '["2011-01-01", "2011-01-01 01:00:00"]')
 
-    j5 = json.dumps(ts, cls=utils._plotlyJSONEncoder)
+    j5 = json.dumps(ts, cls=utils.PlotlyJSONEncoder)
     assert(j5 == '[1.5, 2.5]')
     assert_series_equal(ts, pd.Series([1.5, 2.5], index=rng))
 
-    j6 = json.dumps(ts.index, cls=utils._plotlyJSONEncoder)
+    j6 = json.dumps(ts.index, cls=utils.PlotlyJSONEncoder)
     assert(j6 == '["2011-01-01", "2011-01-01 01:00:00"]')
 
 
 def test_numpy_masked_json_encoding():
     l = [1, 2, np.ma.core.masked]
-    j1 = json.dumps(l, cls=utils._plotlyJSONEncoder)
+    j1 = json.dumps(l, cls=utils.PlotlyJSONEncoder)
+    print j1
     assert(j1 == '[1, 2, NaN]')
     assert(set(l) == set([1, 2, np.ma.core.masked]))
 
@@ -142,23 +271,23 @@ def test_masked_constants_example():
     renderer = PlotlyRenderer()
     Exporter(renderer).run(fig)
 
-    json.dumps(renderer.plotly_fig, cls=utils._plotlyJSONEncoder)
+    json.dumps(renderer.plotly_fig, cls=utils.PlotlyJSONEncoder)
 
     jy = json.dumps(renderer.plotly_fig['data'][1]['y'],
-                    cls=utils._plotlyJSONEncoder)
+                    cls=utils.PlotlyJSONEncoder)
     assert(jy == '[-398.11793026999999, -398.11792966000002, '
                  '-398.11786308000001, NaN]')
 
 
 def test_numpy_dates():
     a = np.arange(np.datetime64('2011-07-11'), np.datetime64('2011-07-18'))
-    j1 = json.dumps(a, cls=utils._plotlyJSONEncoder)
+    j1 = json.dumps(a, cls=utils.PlotlyJSONEncoder)
     assert(j1 == '["2011-07-11", "2011-07-12", "2011-07-13", '
                  '"2011-07-14", "2011-07-15", "2011-07-16", '
                  '"2011-07-17"]')
 
 
 def test_datetime_dot_date():
     a = [datetime.date(2014, 1, 1), datetime.date(2014, 1, 2)]
-    j1 = json.dumps(a, cls=utils._plotlyJSONEncoder)
+    j1 = json.dumps(a, cls=utils.PlotlyJSONEncoder)
     assert(j1 == '["2014-01-01", "2014-01-02"]')