Python BokehJSONEncoder Examples

Example #1

File: test_json_encoder.py Project: danielmoralesp/python-basics

class TestBokehJSONEncoder(unittest.TestCase):

    def setUp(self):
        from bokeh.core.json_encoder import BokehJSONEncoder
        self.encoder = BokehJSONEncoder()

    def test_fail(self):
        self.assertRaises(TypeError, self.encoder.default, {'testing': 1})

    @skipIf(not is_pandas, "pandas does not work in PyPy.")
    def test_panda_series(self):
        s = pd.Series([1, 3, 5, 6, 8])
        self.assertEqual(self.encoder.default(s), [1, 3, 5, 6, 8])

    def test_numpyarray(self):
        a = np.arange(5)
        self.assertEqual(self.encoder.default(a), [0, 1, 2, 3, 4])

    def test_numpyint(self):
        npint = np.asscalar(np.int64(1))
        self.assertEqual(self.encoder.default(npint), 1)
        self.assertIsInstance(self.encoder.default(npint), int)

    def test_numpyfloat(self):
        npfloat = np.float64(1.33)
        self.assertEqual(self.encoder.default(npfloat), 1.33)
        self.assertIsInstance(self.encoder.default(npfloat), float)

    def test_numpybool_(self):
        nptrue = np.bool_(True)
        self.assertEqual(self.encoder.default(nptrue), True)
        self.assertIsInstance(self.encoder.default(nptrue), bool)

    @skipIf(not is_pandas, "pandas does not work in PyPy.")
    def test_pd_timestamp(self):
        ts = pd.tslib.Timestamp('April 28, 1948')
        self.assertEqual(self.encoder.default(ts), -684115200000)

Example #2

File: test_json_encoder.py Project: chakas/bokeh

class TestBokehJSONEncoder(unittest.TestCase):

    def setUp(self):
        from bokeh.core.json_encoder import BokehJSONEncoder
        self.encoder = BokehJSONEncoder()

    def test_fail(self):
        self.assertRaises(TypeError, self.encoder.default, {'testing': 1})

    @skipIf(not is_pandas, "pandas does not work in PyPy.")
    def test_panda_series(self):
        s = pd.Series([1, 3, 5, 6, 8])
        self.assertEqual(self.encoder.default(s), [1, 3, 5, 6, 8])

    def test_numpyarray(self):
        a = np.arange(5)
        self.assertEqual(self.encoder.default(a), [0, 1, 2, 3, 4])

    def test_numpyint(self):
        npint = np.asscalar(np.int64(1))
        self.assertEqual(self.encoder.default(npint), 1)
        self.assertIsInstance(self.encoder.default(npint), int)

    def test_numpyfloat(self):
        npfloat = np.float64(1.33)
        self.assertEqual(self.encoder.default(npfloat), 1.33)
        self.assertIsInstance(self.encoder.default(npfloat), float)

    def test_numpybool_(self):
        nptrue = np.bool_(True)
        self.assertEqual(self.encoder.default(nptrue), True)
        self.assertIsInstance(self.encoder.default(nptrue), bool)

    @skipIf(not is_pandas, "pandas does not work in PyPy.")
    def test_pd_timestamp(self):
        ts = pd.tslib.Timestamp('April 28, 1948')
        self.assertEqual(self.encoder.default(ts), -684115200000)

Example #3

 def setup_method(self, test_method):
     from bokeh.core.json_encoder import BokehJSONEncoder
     self.encoder = BokehJSONEncoder()

Example #4

class TestBokehJSONEncoder(object):
    def setup_method(self, test_method):
        from bokeh.core.json_encoder import BokehJSONEncoder
        self.encoder = BokehJSONEncoder()

    def test_fail(self):
        with pytest.raises(TypeError):
            self.encoder.default({'testing': 1})

    def test_panda_series(self, pd):
        s = pd.Series([1, 3, 5, 6, 8])
        assert self.encoder.default(s) == [1, 3, 5, 6, 8]

    def test_numpyarray(self):
        a = np.arange(5)
        assert self.encoder.default(a) == [0, 1, 2, 3, 4]

    def test_numpyint(self):
        npint = np.asscalar(np.int64(1))
        assert self.encoder.default(npint) == 1
        assert isinstance(self.encoder.default(npint), int)

    def test_numpyfloat(self):
        npfloat = np.float64(1.33)
        assert self.encoder.default(npfloat) == 1.33
        assert isinstance(self.encoder.default(npfloat), float)

    def test_numpybool_(self):
        nptrue = np.bool_(True)
        assert self.encoder.default(nptrue) == True
        assert isinstance(self.encoder.default(nptrue), bool)

    def test_numpydatetime64(self):
        npdt64 = np.datetime64('2017-01-01')
        assert self.encoder.default(npdt64) == 1483228800000.0
        assert isinstance(self.encoder.default(npdt64), float)

    def test_time(self):
        dttime = dt.time(12, 32, 15)
        assert self.encoder.default(dttime) == 45135000.0
        assert isinstance(self.encoder.default(dttime), float)

    def test_relativedelta(self):
        rdelt = rd.relativedelta()
        assert isinstance(self.encoder.default(rdelt), dict)

    def test_decimal(self):
        dec = decimal.Decimal(20.3)
        assert self.encoder.default(dec) == 20.3
        assert isinstance(self.encoder.default(dec), float)

    def test_model(self):
        m = Range1d(start=10, end=20)
        assert self.encoder.default(m) == m.ref
        assert isinstance(self.encoder.default(m), dict)

    def test_hasprops(self):
        hp = HP()
        assert self.encoder.default(hp) == {}
        assert isinstance(self.encoder.default(hp), dict)

        hp.foo = 15
        assert self.encoder.default(hp) == {'foo': 15}
        assert isinstance(self.encoder.default(hp), dict)

        hp.bar = "test"
        assert self.encoder.default(hp) == {'foo': 15, 'bar': 'test'}
        assert isinstance(self.encoder.default(hp), dict)

    def test_color(self):
        c = RGB(16, 32, 64)
        assert self.encoder.default(c) == "rgb(16, 32, 64)"
        assert isinstance(self.encoder.default(c), string_types)

        c = RGB(16, 32, 64, 0.1)
        assert self.encoder.default(c) == "rgba(16, 32, 64, 0.1)"
        assert isinstance(self.encoder.default(c), string_types)

    def test_slice(self):
        c = slice(2)
        assert self.encoder.default(c) == dict(start=None, stop=2, step=None)
        assert isinstance(self.encoder.default(c), dict)

        c = slice(0, 2)
        assert self.encoder.default(c) == dict(start=0, stop=2, step=None)
        assert isinstance(self.encoder.default(c), dict)

        c = slice(0, 10, 2)
        assert self.encoder.default(c) == dict(start=0, stop=10, step=2)
        assert isinstance(self.encoder.default(c), dict)

        c = slice(0, None, 2)
        assert self.encoder.default(c) == dict(start=0, stop=None, step=2)
        assert isinstance(self.encoder.default(c), dict)

        c = slice(None, None, None)
        assert self.encoder.default(c) == dict(start=None,
                                               stop=None,
                                               step=None)
        assert isinstance(self.encoder.default(c), dict)

    def test_pd_timestamp(self, pd):
        ts = pd.Timestamp('April 28, 1948')
        assert self.encoder.default(ts) == -684115200000

Example #5

File: test_json_encoder.py Project: chakas/bokeh

 def setUp(self):
     from bokeh.core.json_encoder import BokehJSONEncoder
     self.encoder = BokehJSONEncoder()

Example #6

File: test_json_encoder.py Project: FourtekIT-incubator/bokeh

class TestBokehJSONEncoder(unittest.TestCase):

    def setUp(self):
        from bokeh.core.json_encoder import BokehJSONEncoder
        self.encoder = BokehJSONEncoder()

    def test_fail(self):
        self.assertRaises(TypeError, self.encoder.default, {'testing': 1})

    @skipIf(not is_pandas, "pandas does not work in PyPy.")
    def test_panda_series(self):
        s = pd.Series([1, 3, 5, 6, 8])
        self.assertEqual(self.encoder.default(s), [1, 3, 5, 6, 8])

    def test_numpyarray(self):
        a = np.arange(5)
        self.assertEqual(self.encoder.default(a), [0, 1, 2, 3, 4])

    def test_numpyint(self):
        npint = np.asscalar(np.int64(1))
        self.assertEqual(self.encoder.default(npint), 1)
        self.assertIsInstance(self.encoder.default(npint), int)

    def test_numpyfloat(self):
        npfloat = np.float64(1.33)
        self.assertEqual(self.encoder.default(npfloat), 1.33)
        self.assertIsInstance(self.encoder.default(npfloat), float)

    def test_numpybool_(self):
        nptrue = np.bool_(True)
        self.assertEqual(self.encoder.default(nptrue), True)
        self.assertIsInstance(self.encoder.default(nptrue), bool)

    def test_numpydatetime64(self):
        npdt64 = np.datetime64('2017-01-01')
        self.assertEqual(self.encoder.default(npdt64), 1483228800000.0)
        self.assertIsInstance(self.encoder.default(npdt64), float)

    def test_time(self):
        dttime = dt.time(12, 32, 15)
        self.assertEqual(self.encoder.default(dttime), 45135000.0)
        self.assertIsInstance(self.encoder.default(dttime), float)

    def test_relativedelta(self):
        rdelt = rd.relativedelta()
        self.assertIsInstance(self.encoder.default(rdelt), dict)

    def test_decimal(self):
        dec = decimal.Decimal(20.3)
        self.assertEqual(self.encoder.default(dec), 20.3)
        self.assertIsInstance(self.encoder.default(dec), float)

    def test_model(self):
        m = Range1d(start=10, end=20)
        self.assertEqual(self.encoder.default(m), m.ref)
        self.assertIsInstance(self.encoder.default(m), dict)

    def test_hasprops(self):
        hp = HP()
        self.assertEqual(self.encoder.default(hp), {})
        self.assertIsInstance(self.encoder.default(hp), dict)

        hp.foo = 15
        self.assertEqual(self.encoder.default(hp), {'foo': 15})
        self.assertIsInstance(self.encoder.default(hp), dict)

        hp.bar = "test"
        self.assertEqual(self.encoder.default(hp), {'foo': 15, 'bar': 'test'})
        self.assertIsInstance(self.encoder.default(hp), dict)

    def test_color(self):
        c = RGB(16, 32, 64)
        self.assertEqual(self.encoder.default(c), "rgb(16, 32, 64)")
        self.assertIsInstance(self.encoder.default(c), string_types)

        c = RGB(16, 32, 64, 0.1)
        self.assertEqual(self.encoder.default(c), "rgba(16, 32, 64, 0.1)")
        self.assertIsInstance(self.encoder.default(c), string_types)

    def test_slice(self):
        c = slice(2)
        self.assertEqual(self.encoder.default(c), dict(start=None, stop=2, step=None))
        self.assertIsInstance(self.encoder.default(c), dict)

        c = slice(0,2)
        self.assertEqual(self.encoder.default(c), dict(start=0, stop=2, step=None))
        self.assertIsInstance(self.encoder.default(c), dict)

        c = slice(0, 10, 2)
        self.assertEqual(self.encoder.default(c), dict(start=0, stop=10, step=2))
        self.assertIsInstance(self.encoder.default(c), dict)

        c = slice(0, None, 2)
        self.assertEqual(self.encoder.default(c), dict(start=0, stop=None, step=2))
        self.assertIsInstance(self.encoder.default(c), dict)

        c = slice(None, None, None)
        self.assertEqual(self.encoder.default(c), dict(start=None, stop=None, step=None))
        self.assertIsInstance(self.encoder.default(c), dict)

    @skipIf(not is_pandas, "pandas does not work in PyPy.")
    def test_pd_timestamp(self):
        ts = pd.Timestamp('April 28, 1948')
        self.assertEqual(self.encoder.default(ts), -684115200000)

Example #7

 def setUp(self):
     from bokeh.core.json_encoder import BokehJSONEncoder
     self.encoder = BokehJSONEncoder()

Example #8

File: test_json_encoder.py Project: jenniferp1/PyCon2017_bokeh

class TestBokehJSONEncoder(unittest.TestCase):
    def setUp(self):
        from bokeh.core.json_encoder import BokehJSONEncoder
        self.encoder = BokehJSONEncoder()

    def test_fail(self):
        self.assertRaises(TypeError, self.encoder.default, {'testing': 1})

    @skipIf(not is_pandas, "pandas does not work in PyPy.")
    def test_panda_series(self):
        s = pd.Series([1, 3, 5, 6, 8])
        self.assertEqual(self.encoder.default(s), [1, 3, 5, 6, 8])

    def test_numpyarray(self):
        a = np.arange(5)
        self.assertEqual(self.encoder.default(a), [0, 1, 2, 3, 4])

    def test_numpyint(self):
        npint = np.asscalar(np.int64(1))
        self.assertEqual(self.encoder.default(npint), 1)
        self.assertIsInstance(self.encoder.default(npint), int)

    def test_numpyfloat(self):
        npfloat = np.float64(1.33)
        self.assertEqual(self.encoder.default(npfloat), 1.33)
        self.assertIsInstance(self.encoder.default(npfloat), float)

    def test_numpybool_(self):
        nptrue = np.bool_(True)
        self.assertEqual(self.encoder.default(nptrue), True)
        self.assertIsInstance(self.encoder.default(nptrue), bool)

    def test_numpydatetime64(self):
        npdt64 = np.datetime64('2017-01-01')
        self.assertEqual(self.encoder.default(npdt64), 1483228800000.0)
        self.assertIsInstance(self.encoder.default(npdt64), float)

    def test_time(self):
        dttime = dt.time(12, 32, 15)
        self.assertEqual(self.encoder.default(dttime), 45135000.0)
        self.assertIsInstance(self.encoder.default(dttime), float)

    def test_relativedelta(self):
        rdelt = rd.relativedelta()
        self.assertIsInstance(self.encoder.default(rdelt), dict)

    def test_decimal(self):
        dec = decimal.Decimal(20.3)
        self.assertEqual(self.encoder.default(dec), 20.3)
        self.assertIsInstance(self.encoder.default(dec), float)

    def test_model(self):
        m = Range1d(start=10, end=20)
        self.assertEqual(self.encoder.default(m), m.ref)
        self.assertIsInstance(self.encoder.default(m), dict)

    def test_hasprops(self):
        hp = HP()
        self.assertEqual(self.encoder.default(hp), {})
        self.assertIsInstance(self.encoder.default(hp), dict)

        hp.foo = 15
        self.assertEqual(self.encoder.default(hp), {'foo': 15})
        self.assertIsInstance(self.encoder.default(hp), dict)

        hp.bar = "test"
        self.assertEqual(self.encoder.default(hp), {'foo': 15, 'bar': 'test'})
        self.assertIsInstance(self.encoder.default(hp), dict)

    def test_color(self):
        c = RGB(16, 32, 64)
        self.assertEqual(self.encoder.default(c), "rgb(16, 32, 64)")
        self.assertIsInstance(self.encoder.default(c), string_types)

        c = RGB(16, 32, 64, 0.1)
        self.assertEqual(self.encoder.default(c), "rgba(16, 32, 64, 0.1)")
        self.assertIsInstance(self.encoder.default(c), string_types)

    @skipIf(not is_pandas, "pandas does not work in PyPy.")
    def test_pd_timestamp(self):
        ts = pd.Timestamp('April 28, 1948')
        self.assertEqual(self.encoder.default(ts), -684115200000)

Example #9

File: test_json_encoder.py Project: jakirkham/bokeh

 def setup_method(self, test_method):
     from bokeh.core.json_encoder import BokehJSONEncoder
     self.encoder = BokehJSONEncoder()

Example #10

File: test_json_encoder.py Project: jakirkham/bokeh

class TestBokehJSONEncoder(object):

    def setup_method(self, test_method):
        from bokeh.core.json_encoder import BokehJSONEncoder
        self.encoder = BokehJSONEncoder()

    def test_fail(self):
        with pytest.raises(TypeError):
            self.encoder.default({'testing': 1})

    def test_panda_series(self, pd):
        s = pd.Series([1, 3, 5, 6, 8])
        assert self.encoder.default(s) == [1, 3, 5, 6, 8]

    def test_numpyarray(self):
        a = np.arange(5)
        assert self.encoder.default(a) == [0, 1, 2, 3, 4]

    def test_numpyint(self):
        npint = np.asscalar(np.int64(1))
        assert self.encoder.default(npint) == 1
        assert isinstance(self.encoder.default(npint), int)

    def test_numpyfloat(self):
        npfloat = np.float64(1.33)
        assert self.encoder.default(npfloat) == 1.33
        assert isinstance(self.encoder.default(npfloat), float)

    def test_numpybool_(self):
        nptrue = np.bool_(True)
        assert self.encoder.default(nptrue) == True
        assert isinstance(self.encoder.default(nptrue), bool)

    def test_numpydatetime64(self):
        npdt64 = np.datetime64('2017-01-01')
        assert self.encoder.default(npdt64) == 1483228800000.0
        assert isinstance(self.encoder.default(npdt64), float)

    def test_time(self):
        dttime = dt.time(12, 32, 15)
        assert self.encoder.default(dttime) == 45135000.0
        assert isinstance(self.encoder.default(dttime), float)

    def test_relativedelta(self):
        rdelt = rd.relativedelta()
        assert isinstance(self.encoder.default(rdelt), dict)

    def test_decimal(self):
        dec = decimal.Decimal(20.3)
        assert self.encoder.default(dec) == 20.3
        assert isinstance(self.encoder.default(dec), float)

    def test_model(self):
        m = Range1d(start=10, end=20)
        assert self.encoder.default(m) == m.ref
        assert isinstance(self.encoder.default(m), dict)

    def test_hasprops(self):
        hp = HP()
        assert self.encoder.default(hp) == {}
        assert isinstance(self.encoder.default(hp), dict)

        hp.foo = 15
        assert self.encoder.default(hp) == {'foo': 15}
        assert isinstance(self.encoder.default(hp), dict)

        hp.bar = "test"
        assert self.encoder.default(hp) == {'foo': 15, 'bar': 'test'}
        assert isinstance(self.encoder.default(hp), dict)

    def test_color(self):
        c = RGB(16, 32, 64)
        assert self.encoder.default(c) == "rgb(16, 32, 64)"
        assert isinstance(self.encoder.default(c), string_types)

        c = RGB(16, 32, 64, 0.1)
        assert self.encoder.default(c) == "rgba(16, 32, 64, 0.1)"
        assert isinstance(self.encoder.default(c), string_types)

    def test_slice(self):
        c = slice(2)
        assert self.encoder.default(c) == dict(start=None, stop=2, step=None)
        assert isinstance(self.encoder.default(c), dict)

        c = slice(0,2)
        assert self.encoder.default(c) == dict(start=0, stop=2, step=None)
        assert isinstance(self.encoder.default(c), dict)

        c = slice(0, 10, 2)
        assert self.encoder.default(c) == dict(start=0, stop=10, step=2)
        assert isinstance(self.encoder.default(c), dict)

        c = slice(0, None, 2)
        assert self.encoder.default(c) == dict(start=0, stop=None, step=2)
        assert isinstance(self.encoder.default(c), dict)

        c = slice(None, None, None)
        assert self.encoder.default(c) == dict(start=None, stop=None, step=None)
        assert isinstance(self.encoder.default(c), dict)

    def test_pd_timestamp(self, pd):
        ts = pd.Timestamp('April 28, 1948')
        assert self.encoder.default(ts) == -684115200000