Exemplo n.º 1
0
    def test_serialize(self):
        """Objects are serialized to JSON-compatible objects"""
        def epoch(obj):
            """Convert to JS Epoch time"""
            return int(time.mktime(obj.timetuple())) * 1000

        types = [('test', str, 'test'),
                 (pd.Timestamp('2013-06-08'), int,
                  epoch(pd.Timestamp('2013-06-08'))),
                 (datetime.utcnow(), int, epoch(datetime.utcnow())),
                 (1, int, 1), (1.0, float, 1.0), (np.float32(1), float, 1.0),
                 (np.int32(1), int, 1), (np.float64(1), float, 1.0),
                 (np.int64(1), int, 1)]

        for puts, pytype, gets in types:
            nt.assert_equal(Data.serialize(puts), gets)

        class BadType(object):
            """Bad object for type warning"""

        test_obj = BadType()
        with nt.assert_raises(LoadError) as err:
            Data.serialize(test_obj)
        nt.assert_equals(err.exception.args[0],
                         'cannot serialize index of type BadType')
Exemplo n.º 2
0
    def test_serialize(self):
        """Objects are serialized to JSON-compatible objects"""

        def epoch(obj):
            """Convert to JS Epoch time"""
            return int(time.mktime(obj.timetuple())) * 1000

        types = [('test', str, 'test'),
                 (pd.Timestamp('2013-06-08'), int,
                  epoch(pd.Timestamp('2013-06-08'))),
                 (datetime.utcnow(), int, epoch(datetime.utcnow())),
                 (1, int, 1),
                 (1.0, float, 1.0),
                 (np.float32(1), float, 1.0),
                 (np.int32(1), int, 1),
                 (np.float64(1), float, 1.0),
                 (np.int64(1), int, 1)]

        for puts, pytype, gets in types:
            nt.assert_equal(Data.serialize(puts), gets)

        class BadType(object):
            """Bad object for type warning"""

        test_obj = BadType()
        with nt.assert_raises(LoadError) as err:
            Data.serialize(test_obj)
        nt.assert_equals(err.exception.message,
                         'cannot serialize index of type BadType')
Exemplo n.º 3
0
    def test_pandas_series_loading(self):
        """Pandas Series objects are correctly loaded"""
        # Test valid series types
        name = ['_x', ' name']
        length = [0, 1, 2]
        index_key = [None, 'ix', 1]
        index_types = ['int', 'char', 'datetime', 'Timestamp']
        value_key = [None, 'x', 1]
        value_types = ['int', 'char', 'datetime', 'Timestamp', 'float',
                       'numpy float', 'numpy int']

        series_info = product(name, length, index_key, index_types,
                              value_key, value_types)

        for n, l, ikey, itype, vkey, vtype in series_info:
            index = sequences[itype](l)
            series = pd.Series(sequences[vtype](l), index=index, name=n,)

            vkey = vkey or series.name
            expected = [{'idx': Data.serialize(i), 'col': vkey,
                         'val': Data.serialize(v)}
                        for i, v in zip(index, series)]

            data = Data.from_pandas(series, name=n, series_key=vkey)
            nt.assert_list_equal(expected, data.values)
            nt.assert_equal(n, data.name)
            data.to_json()

        # Missing a name
        series = pd.Series(np.random.randn(10))
        data = Data.from_pandas(series)
        nt.assert_equal(data.name, 'table')
Exemplo n.º 4
0
    def test_pandas_series_loading(self):
        """Pandas Series objects are correctly loaded"""
        # Test valid series types
        name = ['_x', ' name']
        length = [0, 1, 2]
        index_key = [None, 'ix', 1]
        index_types = ['int', 'char', 'datetime', 'Timestamp']
        value_key = [None, 'x', 1]
        value_types = ['int', 'char', 'datetime', 'Timestamp', 'float',
                       'numpy float', 'numpy int']

        series_info = product(name, length, index_key, index_types,
                              value_key, value_types)

        for n, l, ikey, itype, vkey, vtype in series_info:
            index = sequences[itype](l)
            series = pd.Series(sequences[vtype](l), index=index, name=n,)

            vkey = series.name or vkey
            expected = [{'idx': Data.serialize(i), 'col': vkey,
                         'val': Data.serialize(v)}
                        for i, v in zip(index, series)]

            data = Data.from_pandas(series, name=n, series_key=vkey)
            nt.assert_list_equal(expected, data.values)
            nt.assert_equal(n, data.name)
            data.to_json()

        # Missing a name
        series = pd.Series(np.random.randn(10))
        data = Data.from_pandas(series)
        nt.assert_equal(data.name, 'table')
Exemplo n.º 5
0
    def test_from_mult_iters(self):
        """Test set of iterables"""
        test1 = Data.from_mult_iters(x=[0, 1, 2],
                                     y=[3, 4, 5],
                                     z=[7, 8, 9],
                                     idx='x')
        test2 = Data.from_mult_iters(fruit=['apples', 'oranges', 'grapes'],
                                     count=[12, 16, 54],
                                     idx='fruit')
        values1 = [{
            'col': 'y',
            'idx': 0,
            'val': 3
        }, {
            'col': 'y',
            'idx': 1,
            'val': 4
        }, {
            'col': 'y',
            'idx': 2,
            'val': 5
        }, {
            'col': 'z',
            'idx': 0,
            'val': 7
        }, {
            'col': 'z',
            'idx': 1,
            'val': 8
        }, {
            'col': 'z',
            'idx': 2,
            'val': 9
        }]
        values2 = [{
            'col': 'count',
            'idx': 'apples',
            'val': 12
        }, {
            'col': 'count',
            'idx': 'oranges',
            'val': 16
        }, {
            'col': 'count',
            'idx': 'grapes',
            'val': 54
        }]

        nt.assert_list_equal(test1.values, values1)
        nt.assert_list_equal(test2.values, values2)

        #Iter errors
        nt.assert_raises(ValueError, Data.from_mult_iters, x=[0], y=[1, 2])
Exemplo n.º 6
0
 def test_from_iter(self):
     """Test data from single iterable"""
     test_list = Data.from_iter([10, 20, 30])
     test_dict = Data.from_iter({'apples': 10, 'bananas': 20, 'oranges': 30})
     get1 = [{'col': 'data', 'idx': 0, 'val': 10},
             {'col': 'data', 'idx': 1, 'val': 20},
             {'col': 'data', 'idx': 2, 'val': 30}]
     get2 = [{'col': 'data', 'idx': 'apples', 'val': 10},
             {'col': 'data', 'idx': 'oranges', 'val': 30},
             {'col': 'data', 'idx': 'bananas', 'val': 20}]
     nt.assert_list_equal(test_list.values, get1)
     nt.assert_list_equal(test_dict.values, get2)
Exemplo n.º 7
0
 def test_from_iter(self):
     """Test data from single iterable"""
     test_list = Data.from_iter([10, 20, 30])
     test_dict = Data.from_iter({'apples': 10, 'bananas': 20, 'oranges': 30})
     get1 = [{'col': 'data', 'idx': 0, 'val': 10},
             {'col': 'data', 'idx': 1, 'val': 20},
             {'col': 'data', 'idx': 2, 'val': 30}]
     get2 = [{'col': 'data', 'idx': 'apples', 'val': 10},
             {'col': 'data', 'idx': 'oranges', 'val': 30},
             {'col': 'data', 'idx': 'bananas', 'val': 20}]
     nt.assert_list_equal(test_list.values, get1)
     nt.assert_list_equal(test_dict.values, get2)
Exemplo n.º 8
0
    def test_validation(self):
        """Test Visualization validation"""

        test_obj = Visualization()
        with nt.assert_raises(ValidationError) as err:
            test_obj.validate()
        nt.assert_equal(err.exception.args[0],
                        'data must be defined for valid visualization')

        test_obj.data = [Data(name='test'), Data(name='test')]
        with nt.assert_raises(ValidationError) as err:
            test_obj.validate()
        nt.assert_equal(err.exception.args[0], 'data has duplicate names')
Exemplo n.º 9
0
    def test_grammar_typechecking(self):
        """Data fields are correctly type-checked"""
        grammar_types = [
            ('name', [str]),
            ('url', [str]),
            ('values', [list]),
            ('source', [str]),
            ('transform', [list])]

        assert_grammar_typechecking(grammar_types, Data('name'))
Exemplo n.º 10
0
    def test_from_mult_iters(self):
        """Test set of iterables"""
        test1 = Data.from_mult_iters(x=[0, 1, 2], y=[3, 4, 5], z=[7, 8, 9],
                                     idx='x')
        test2 = Data.from_mult_iters(fruit=['apples', 'oranges', 'grapes'],
                                     count=[12, 16, 54], idx='fruit')
        values1 = [{'col': 'y', 'idx': 0, 'val': 3},
                   {'col': 'y', 'idx': 1, 'val': 4},
                   {'col': 'y', 'idx': 2, 'val': 5},
                   {'col': 'z', 'idx': 0, 'val': 7},
                   {'col': 'z', 'idx': 1, 'val': 8},
                   {'col': 'z', 'idx': 2, 'val': 9}]
        values2 = [{'col': 'count', 'idx': 'apples', 'val': 12},
                   {'col': 'count', 'idx': 'oranges', 'val': 16},
                   {'col': 'count', 'idx': 'grapes', 'val': 54}]

        nt.assert_list_equal(test1.values, values1)
        nt.assert_list_equal(test2.values, values2)

        #Iter errors
        nt.assert_raises(ValueError, Data.from_mult_iters, x=[0], y=[1, 2])
Exemplo n.º 11
0
    def test_numpy_loading(self):
        """Numpy ndarray objects are correctly loaded"""
        test_data = np.random.randn(6, 3)
        index = range(test_data.shape[0])
        columns = ['a', 'b', 'c']

        data = Data.from_numpy(test_data, name='name', columns=columns)
        ikey = Data._default_index_key
        expected_values = [{
            ikey: i,
            'a': row[0],
            'b': row[1],
            'c': row[2]
        } for i, row in zip(index, test_data.tolist())]
        nt.assert_list_equal(expected_values, data.values)
        nt.assert_equal('name', data.name)

        index_key = 'akey'
        data = Data.from_numpy(test_data,
                               name='name',
                               columns=columns,
                               index_key=index_key)
        expected_values = [{
            index_key: i,
            'a': row[0],
            'b': row[1],
            'c': row[2]
        } for i, row in zip(index, test_data.tolist())]
        nt.assert_list_equal(expected_values, data.values)

        index = ['a', 'b', 'c', 'd', 'e', 'f']
        data = Data.from_numpy(test_data,
                               name='name',
                               index=index,
                               columns=columns)
        expected_values = [{
            ikey: i,
            'a': row[0],
            'b': row[1],
            'c': row[2]
        } for i, row in zip(index, test_data.tolist())]
        nt.assert_list_equal(expected_values, data.values)

        #Bad loads
        with nt.assert_raises(LoadError) as err:
            Data.from_numpy(test_data, 'test', columns, index=range(4))
        nt.assert_equal(err.expected, LoadError)

        columns = ['a', 'b']
        with nt.assert_raises(LoadError) as err:
            Data.from_numpy(test_data, 'test', columns, index)
        nt.assert_equal(err.expected, LoadError)
Exemplo n.º 12
0
    def test_pandas_dataframe_loading(self):

        # Simple columns/key_on tests
        df = pd.DataFrame({'one': [1, 2, 3], 'two': [6, 7, 8],
                           'three': [11, 12, 13], 'four': [17, 18, 19]})
        get_all = [{'col': 'four', 'idx': 0, 'val': 17},
                   {'col': 'one', 'idx': 0, 'val': 1},
                   {'col': 'three', 'idx': 0, 'val': 11},
                   {'col': 'two', 'idx': 0, 'val': 6},
                   {'col': 'four', 'idx': 1, 'val': 18},
                   {'col': 'one', 'idx': 1, 'val': 2},
                   {'col': 'three', 'idx': 1, 'val': 12},
                   {'col': 'two', 'idx': 1, 'val': 7},
                   {'col': 'four', 'idx': 2, 'val': 19},
                   {'col': 'one', 'idx': 2, 'val': 3},
                   {'col': 'three', 'idx': 2, 'val': 13},
                   {'col': 'two', 'idx': 2, 'val': 8}]
        get1 = [{'col': 'one', 'idx': 0, 'val': 1},
                {'col': 'one', 'idx': 1, 'val': 2},
                {'col': 'one', 'idx': 2, 'val': 3}]
        get2 = [{'col': 'one', 'idx': 0, 'val': 1},
                {'col': 'two', 'idx': 0, 'val': 6},
                {'col': 'one', 'idx': 1, 'val': 2},
                {'col': 'two', 'idx': 1, 'val': 7},
                {'col': 'one', 'idx': 2, 'val': 3},
                {'col': 'two', 'idx': 2, 'val': 8}]
        getkey2 = [{'col': 'one', 'idx': 6, 'val': 1},
                   {'col': 'one', 'idx': 7, 'val': 2},
                   {'col': 'one', 'idx': 8, 'val': 3}]
        getkey3 = [{'col': 'one', 'idx': 11, 'val': 1},
                   {'col': 'two', 'idx': 11, 'val': 6},
                   {'col': 'one', 'idx': 12, 'val': 2},
                   {'col': 'two', 'idx': 12, 'val': 7},
                   {'col': 'one', 'idx': 13, 'val': 3},
                   {'col': 'two', 'idx': 13, 'val': 8}]
        val_all = Data.from_pandas(df)
        val1 = Data.from_pandas(df, columns=['one'])
        val2 = Data.from_pandas(df, columns=['one', 'two'])
        key2 = Data.from_pandas(df, columns=['one'], key_on='two')
        key3 = Data.from_pandas(df, columns=['one', 'two'], key_on='three')

        nt.assert_list_equal(val_all.values, get_all)
        nt.assert_list_equal(val1.values, get1)
        nt.assert_list_equal(val2.values, get2)
        nt.assert_list_equal(key2.values, getkey2)
        nt.assert_list_equal(key3.values, getkey3)

        # Missing a name
        dataframe = pd.DataFrame(np.random.randn(10, 3))
        data = Data.from_pandas(dataframe)
        nt.assert_equal(data.name, 'table')

        # Bad obj
        nt.assert_raises(ValueError, Data.from_pandas, {})
Exemplo n.º 13
0
    def test_numpy_loading(self):
        """Numpy ndarray objects are correctly loaded"""
        test_data = np.random.randn(6, 3)
        index = xrange(test_data.shape[0])
        columns = ['a', 'b', 'c']

        data = Data.from_numpy(test_data, name='name', columns=columns)
        ikey = Data._default_index_key
        expected_values = [
            {ikey: i, 'a': row[0], 'b': row[1], 'c': row[2]}
            for i, row in zip(index, test_data.tolist())]
        nt.assert_list_equal(expected_values, data.values)
        nt.assert_equal('name', data.name)

        index_key = 'akey'
        data = Data.from_numpy(test_data, name='name', columns=columns,
                               index_key=index_key)
        expected_values = [
            {index_key: i, 'a': row[0], 'b': row[1], 'c': row[2]}
            for i, row in zip(index, test_data.tolist())]
        nt.assert_list_equal(expected_values, data.values)

        index = ['a', 'b', 'c', 'd', 'e', 'f']
        data = Data.from_numpy(test_data, name='name', index=index,
                               columns=columns)
        expected_values = [
            {ikey: i, 'a': row[0], 'b': row[1], 'c': row[2]}
            for i, row in zip(index, test_data.tolist())]
        nt.assert_list_equal(expected_values, data.values)

        #Bad loads
        with nt.assert_raises(LoadError) as err:
            Data.from_numpy(test_data, 'test', columns, index=xrange(4))
        nt.assert_equal(err.expected, LoadError)

        columns = ['a', 'b']
        with nt.assert_raises(LoadError) as err:
            Data.from_numpy(test_data, 'test', columns, index)
        nt.assert_equal(err.expected, LoadError)
Exemplo n.º 14
0
    def test_pandas_dataframe_loading(self):
        """Pandas DataFrame objects are correctly loaded"""
        # name = ['_x']
        # length = [0, 1, 2]
        # index_key = [None, 'ix', 1]
        # index_types = ['int', 'char', 'datetime', 'Timestamp']
        # column_types = ['int', 'char', 'datetime', 'Timestamp']

        # # Leaving out some basic types here because we're not worried about
        # # serialization.
        # value_types = [
        #     'char', 'datetime', 'Timestamp', 'numpy float', 'numpy int']

        # dataframe_info = product(
        #     name, length, length, index_key, index_types, column_types,
        #     value_types)
        # for n, rows, cols, ikey, itype, ctype, vtype in dataframe_info:
        #     index = sequences[itype](rows)
        #     columns = sequences[ctype](cols)
        #     series = {
        #         c: pd.Series(sequences[vtype](rows), index=index, name=n)
        #         for c in columns}
        #     dataframe = pd.DataFrame(series)

        #     ikey = ikey or Data._default_index_key
        #     if cols == 0:
        #         expected = []
        #     else:
        #         expected = [
        #             dict([(ikey, Data.serialize(index[i]))] +
        #                  [(str(c), Data.serialize(series[c][i]))
        #                   for c in columns])
        #             for i in xrange(rows)]

        #     data = Data.from_pandas(dataframe, name=n, index_key=ikey)
        #     nt.assert_list_equal(expected, data.values)
        #     nt.assert_equal(n, data.name)
        #     data.to_json()

        #Simple columns/key_on tests
        df = pd.DataFrame({'one': [1,2,3], 'two': [6,7,8],
                           'three': [11, 12, 13], 'four': [17, 18, 19]})
        get_all = [{'col': 'four', 'idx': 0, 'val': 17},
                   {'col': 'one', 'idx': 0, 'val': 1},
                   {'col': 'three', 'idx': 0, 'val': 11},
                   {'col': 'two', 'idx': 0, 'val': 6},
                   {'col': 'four', 'idx': 1, 'val': 18},
                   {'col': 'one', 'idx': 1, 'val': 2},
                   {'col': 'three', 'idx': 1, 'val': 12},
                   {'col': 'two', 'idx': 1, 'val': 7},
                   {'col': 'four', 'idx': 2, 'val': 19},
                   {'col': 'one', 'idx': 2, 'val': 3},
                   {'col': 'three', 'idx': 2, 'val': 13},
                   {'col': 'two', 'idx': 2, 'val': 8}]
        get1 = [{'col': 'one', 'idx': 0, 'val': 1},
                {'col': 'one', 'idx': 1, 'val': 2},
                {'col': 'one', 'idx': 2, 'val': 3}]
        get2 = [{'col': 'one', 'idx': 0, 'val': 1},
                {'col': 'two', 'idx': 0, 'val': 6},
                {'col': 'one', 'idx': 1, 'val': 2},
                {'col': 'two', 'idx': 1, 'val': 7},
                {'col': 'one', 'idx': 2, 'val': 3},
                {'col': 'two', 'idx': 2, 'val': 8}]
        getkey2 = [{'col': 'one', 'idx': 6, 'val': 1},
                   {'col': 'one', 'idx': 7, 'val': 2},
                   {'col': 'one', 'idx': 8, 'val': 3}]
        getkey3 = [{'col': 'one', 'idx': 11, 'val': 1},
                   {'col': 'two', 'idx': 11, 'val': 6},
                   {'col': 'one', 'idx': 12, 'val': 2},
                   {'col': 'two', 'idx': 12, 'val': 7},
                   {'col': 'one', 'idx': 13, 'val': 3},
                   {'col': 'two', 'idx': 13, 'val': 8}]
        val_all = Data.from_pandas(df)
        val1 = Data.from_pandas(df, columns=['one'])
        val2 = Data.from_pandas(df, columns=['one', 'two'])
        key2 = Data.from_pandas(df, columns=['one'], key_on='two')
        key3 = Data.from_pandas(df, columns=['one', 'two'], key_on='three')

        nt.assert_list_equal(val_all.values, get_all)
        nt.assert_list_equal(val1.values, get1)
        nt.assert_list_equal(val2.values, get2)
        nt.assert_list_equal(key2.values, getkey2)
        nt.assert_list_equal(key3.values, getkey3)

        # Missing a name
        dataframe = pd.DataFrame(np.random.randn(10, 3))
        data = Data.from_pandas(dataframe)
        nt.assert_equal(data.name, 'table')

        #Bad obj
        nt.assert_raises(ValueError, Data.from_pandas, {})
Exemplo n.º 15
0
    def test_pandas_dataframe_loading(self):

        # Simple columns/key_on tests
        df = pd.DataFrame({
            'one': [1, 2, 3],
            'two': [6, 7, 8],
            'three': [11, 12, 13],
            'four': [17, 18, 19]
        })
        get_all = [{
            'col': 'four',
            'idx': 0,
            'val': 17
        }, {
            'col': 'one',
            'idx': 0,
            'val': 1
        }, {
            'col': 'three',
            'idx': 0,
            'val': 11
        }, {
            'col': 'two',
            'idx': 0,
            'val': 6
        }, {
            'col': 'four',
            'idx': 1,
            'val': 18
        }, {
            'col': 'one',
            'idx': 1,
            'val': 2
        }, {
            'col': 'three',
            'idx': 1,
            'val': 12
        }, {
            'col': 'two',
            'idx': 1,
            'val': 7
        }, {
            'col': 'four',
            'idx': 2,
            'val': 19
        }, {
            'col': 'one',
            'idx': 2,
            'val': 3
        }, {
            'col': 'three',
            'idx': 2,
            'val': 13
        }, {
            'col': 'two',
            'idx': 2,
            'val': 8
        }]
        get1 = [{
            'col': 'one',
            'idx': 0,
            'val': 1
        }, {
            'col': 'one',
            'idx': 1,
            'val': 2
        }, {
            'col': 'one',
            'idx': 2,
            'val': 3
        }]
        get2 = [{
            'col': 'one',
            'idx': 0,
            'val': 1
        }, {
            'col': 'two',
            'idx': 0,
            'val': 6
        }, {
            'col': 'one',
            'idx': 1,
            'val': 2
        }, {
            'col': 'two',
            'idx': 1,
            'val': 7
        }, {
            'col': 'one',
            'idx': 2,
            'val': 3
        }, {
            'col': 'two',
            'idx': 2,
            'val': 8
        }]
        getkey2 = [{
            'col': 'one',
            'idx': 6,
            'val': 1
        }, {
            'col': 'one',
            'idx': 7,
            'val': 2
        }, {
            'col': 'one',
            'idx': 8,
            'val': 3
        }]
        getkey3 = [{
            'col': 'one',
            'idx': 11,
            'val': 1
        }, {
            'col': 'two',
            'idx': 11,
            'val': 6
        }, {
            'col': 'one',
            'idx': 12,
            'val': 2
        }, {
            'col': 'two',
            'idx': 12,
            'val': 7
        }, {
            'col': 'one',
            'idx': 13,
            'val': 3
        }, {
            'col': 'two',
            'idx': 13,
            'val': 8
        }]
        val_all = Data.from_pandas(df)
        val1 = Data.from_pandas(df, columns=['one'])
        val2 = Data.from_pandas(df, columns=['one', 'two'])
        key2 = Data.from_pandas(df, columns=['one'], key_on='two')
        key3 = Data.from_pandas(df, columns=['one', 'two'], key_on='three')

        nt.assert_list_equal(val_all.values, get_all)
        nt.assert_list_equal(val1.values, get1)
        nt.assert_list_equal(val2.values, get2)
        nt.assert_list_equal(key2.values, getkey2)
        nt.assert_list_equal(key3.values, getkey3)

        # Missing a name
        dataframe = pd.DataFrame(np.random.randn(10, 3))
        data = Data.from_pandas(dataframe)
        nt.assert_equal(data.name, 'table')

        # Bad obj
        nt.assert_raises(ValueError, Data.from_pandas, {})
Exemplo n.º 16
0
 def test_keypairs(self):
     Data.keypairs([0, 10, 20, 30, 40])
     Data.keypairs(((0, 1), (0, 2), (0, 3)))
     Data.keypairs({'A': 10, 'B': 20, 'C': 30, 'D': 40, 'E': 50})
Exemplo n.º 17
0
 def test_keypairs(self):
     Data.keypairs([0, 10, 20, 30, 40])
     Data.keypairs(((0, 1), (0, 2), (0, 3)))
     Data.keypairs({'A': 10, 'B': 20, 'C': 30, 'D': 40, 'E': 50})
Exemplo n.º 18
0
 def test_validate(self):
     """Test Data name validation"""
     test_obj = Data()
     del test_obj.name
     nt.assert_raises(ValidationError, test_obj.validate)
Exemplo n.º 19
0
    def test_pandas_dataframe_loading(self):
        """Pandas DataFrame objects are correctly loaded"""
        # name = ['_x']
        # length = [0, 1, 2]
        # index_key = [None, 'ix', 1]
        # index_types = ['int', 'char', 'datetime', 'Timestamp']
        # column_types = ['int', 'char', 'datetime', 'Timestamp']

        # # Leaving out some basic types here because we're not worried about
        # # serialization.
        # value_types = [
        #     'char', 'datetime', 'Timestamp', 'numpy float', 'numpy int']

        # dataframe_info = product(
        #     name, length, length, index_key, index_types, column_types,
        #     value_types)
        # for n, rows, cols, ikey, itype, ctype, vtype in dataframe_info:
        #     index = sequences[itype](rows)
        #     columns = sequences[ctype](cols)
        #     series = {
        #         c: pd.Series(sequences[vtype](rows), index=index, name=n)
        #         for c in columns}
        #     dataframe = pd.DataFrame(series)

        #     ikey = ikey or Data._default_index_key
        #     if cols == 0:
        #         expected = []
        #     else:
        #         expected = [
        #             dict([(ikey, Data.serialize(index[i]))] +
        #                  [(str(c), Data.serialize(series[c][i]))
        #                   for c in columns])
        #             for i in xrange(rows)]

        #     data = Data.from_pandas(dataframe, name=n, index_key=ikey)
        #     nt.assert_list_equal(expected, data.values)
        #     nt.assert_equal(n, data.name)
        #     data.to_json()

        #Simple columns/key_on tests
        df = pd.DataFrame({
            'one': [1, 2, 3],
            'two': [6, 7, 8],
            'three': [11, 12, 13],
            'four': [17, 18, 19]
        })
        get_all = [{
            'col': 'four',
            'idx': 0,
            'val': 17
        }, {
            'col': 'one',
            'idx': 0,
            'val': 1
        }, {
            'col': 'three',
            'idx': 0,
            'val': 11
        }, {
            'col': 'two',
            'idx': 0,
            'val': 6
        }, {
            'col': 'four',
            'idx': 1,
            'val': 18
        }, {
            'col': 'one',
            'idx': 1,
            'val': 2
        }, {
            'col': 'three',
            'idx': 1,
            'val': 12
        }, {
            'col': 'two',
            'idx': 1,
            'val': 7
        }, {
            'col': 'four',
            'idx': 2,
            'val': 19
        }, {
            'col': 'one',
            'idx': 2,
            'val': 3
        }, {
            'col': 'three',
            'idx': 2,
            'val': 13
        }, {
            'col': 'two',
            'idx': 2,
            'val': 8
        }]
        get1 = [{
            'col': 'one',
            'idx': 0,
            'val': 1
        }, {
            'col': 'one',
            'idx': 1,
            'val': 2
        }, {
            'col': 'one',
            'idx': 2,
            'val': 3
        }]
        get2 = [{
            'col': 'one',
            'idx': 0,
            'val': 1
        }, {
            'col': 'two',
            'idx': 0,
            'val': 6
        }, {
            'col': 'one',
            'idx': 1,
            'val': 2
        }, {
            'col': 'two',
            'idx': 1,
            'val': 7
        }, {
            'col': 'one',
            'idx': 2,
            'val': 3
        }, {
            'col': 'two',
            'idx': 2,
            'val': 8
        }]
        getkey2 = [{
            'col': 'one',
            'idx': 6,
            'val': 1
        }, {
            'col': 'one',
            'idx': 7,
            'val': 2
        }, {
            'col': 'one',
            'idx': 8,
            'val': 3
        }]
        getkey3 = [{
            'col': 'one',
            'idx': 11,
            'val': 1
        }, {
            'col': 'two',
            'idx': 11,
            'val': 6
        }, {
            'col': 'one',
            'idx': 12,
            'val': 2
        }, {
            'col': 'two',
            'idx': 12,
            'val': 7
        }, {
            'col': 'one',
            'idx': 13,
            'val': 3
        }, {
            'col': 'two',
            'idx': 13,
            'val': 8
        }]
        val_all = Data.from_pandas(df)
        val1 = Data.from_pandas(df, columns=['one'])
        val2 = Data.from_pandas(df, columns=['one', 'two'])
        key2 = Data.from_pandas(df, columns=['one'], key_on='two')
        key3 = Data.from_pandas(df, columns=['one', 'two'], key_on='three')

        nt.assert_list_equal(val_all.values, get_all)
        nt.assert_list_equal(val1.values, get1)
        nt.assert_list_equal(val2.values, get2)
        nt.assert_list_equal(key2.values, getkey2)
        nt.assert_list_equal(key3.values, getkey3)

        # Missing a name
        dataframe = pd.DataFrame(np.random.randn(10, 3))
        data = Data.from_pandas(dataframe)
        nt.assert_equal(data.name, 'table')

        #Bad obj
        nt.assert_raises(ValueError, Data.from_pandas, {})