fix input object format for NDframe

Author: risenW

danfojs/src/core/frame.js

@@ -4,7 +4,7 @@ import { Series } from "./series"
 import * as tf from '@tensorflow/tfjs'
 import { Utils } from "./utils"
 import { GroupBy } from "./groupby"
-// import { Plot } from '../plotting/plot'
+import { Plot } from '../plotting/plot'
 import { indexLoc } from '../core/indexing'
 
 const utils = new Utils
@@ -1895,10 +1895,10 @@ export class DataFrame extends Ndframe {
      * @param {string} div Name of the div to show the plot
      * @param {Object} config configuration options for making Plots, supports Plotly parameters
      */
-    // plot(div, config = {}) {
-    //     const plt = new Plot()
-    //     plt.plot(this, div, config)
-    // }
+    plot(div, config = {}) {
+        const plt = new Plot()
+        plt.plot(this, div, config)
+    }
 
 
     /**

danfojs/src/core/generic.js

@@ -32,9 +32,11 @@ export default class NDframe {
         } else {
             this.series = false
             if (utils.__is_object(data[0])) { //check the type of the first object in the data
-                this.__read_object(data)
+                this.__read_object(data, 1) //type 1 object are of JSON form [{a: 1, b: 2}, {a: 30, b: 20}]
             } else if (Array.isArray(data[0]) || utils.__is_number(data[0]) || utils.__is_string(data[0])) {
                 this.__read_array(data)
+            } else if (utils.__is_object(data)) {
+                this.__read_object(data, 2)  //type 2 object are of the form {a: [1,2,3,4], b: [30,20, 30, 20}]
             } else {
                 throw "File format not supported for now"
             }
@@ -92,19 +94,19 @@ export default class NDframe {
 
 
     //Reads a Javascript Object of arrays of data points
-    __read_object(data) {
-        let data_arr = []
-        //check format of objects
-        let _key = Object.keys(data[0])[0]  //get first column name in data
-        if (Array.isArray(data[0][_key])) {
-            // format of data is [{"a": [1,2,3,4]}, {"b": [2,4,5,7]}]
+    __read_object(data, type) {
+        if (type == 2) {
+            let data_arr = []
+
+            // format of data is {"a": [1,2,3,4], "b": [2,4,5,7]}
             let result = utils.__get_row_values(data)
             data_arr = result[0]
             this.kwargs['columns'] = result[1]
-            //call read array on result since it is an array of array format
             this.__read_array(data_arr)
         } else {
             //format of data is [{"a": 1, "b" : 2}, {"a": 2, "b" : 4}, {"a": 4, "b" : 5}]
+            let data_arr = []
+
             data.forEach((item) => {
                 data_arr.push(Object.values(item))
             });
@@ -355,7 +357,7 @@ export default class NDframe {
             return JSON.stringify(json_arr)
         }
     }
-    
+
 
     /**
     * Prints the data in a Series as a grid of row and columns

danfojs/src/core/utils.js

@@ -149,28 +149,22 @@ export class Utils {
     // let data = [{ alpha: ["A", "B", "C", "D"] }, { count: [1,2,3,4]}, {sum: [20.3, 30.456, 40.90, 90.1]}]
 
 
-    //transpose column array into row array
+    //retrieve row array from column object
     __get_row_values(data) {
-        let rows_len = Object.values(data[0])[0].length
-        let cols_len = data.length
+        let col_names = Object.keys(data)
+        let col_data = Object.values(data)
+        let rows_len = col_data[0].length
+        let cols_len = col_names.length
         var rows_arr = []
 
         for (var i = 0; i <= rows_len - 1; i++) {
             var temp_row = []
             for (let j = 0; j < cols_len; j++) {
-                let _arr = Object.values(data[j])[0]
+                let _arr = col_data[j]
                 temp_row.push(_arr[i])
             }
             rows_arr.push(temp_row)
         }
-        //get column names
-        let col_names = []
-        for (let i = 0; i < cols_len; i++) {
-            let _key = Object.keys(data[i])[0]
-            col_names.push(_key)
-
-        }
-
         return [rows_arr, col_names]
 
     }
@@ -638,24 +632,24 @@ export class Utils {
         return zero_data
     }
 
-    __shuffle(num,array) {
+    __shuffle(num, array) {
         //https://stackoverflow.com/questions/18806210/generating-non-repeating-random-numbers-in-js/18806417
         var i = array.length,
             j = 0,
             temp;
-    
+
         while (i--) {
-    
-            j = Math.floor(Math.random() * (i+1));
-    
+
+            j = Math.floor(Math.random() * (i + 1));
+
             // swap randomly chosen element with current element
             temp = array[i];
             array[i] = array[j];
             array[j] = temp;
-    
+
         }
-    
-        return array.slice(0,num);
+
+        return array.slice(0, num);
     }
 }
 

danfojs/src/plotting/plot.js

@@ -1,80 +1,85 @@
-// //perform plotting
-// // import {newPlot} from 'plotly.js/dist/plotly'
-// import { Utils } from "../core/utils"
-// const utils = new Utils()
-
-
-
-// /**
-//  * Plotting methods and Functions performed on Series and DataFrames
-//  */
-// export class Plot {
-//     constructor() {}
-
-//     plot(ndframe, div, config) {
-//         let params = Object.keys(config)
-//         let this_config = {}
-
-//         if (!utils.__key_in_object(config, "layout")){
-//             this_config['layout'] = {}
-//         }
-
-//         params.forEach(param => {
-//             this_config[param] = config[param]
-//         })
-
-//         if (ndframe.series) {
-//             let x = ndframe.values
-//             let trace = {
-//                 x: x,
-//                 type: this_config["kind"],
-//                 mode: this_config["mode"]
-//             }
-//             newPlot(div, [trace], this_config['layout']);
-
-//         } else {
-//             //DataFrame
-//             if (utils.__key_in_object(this_config, 'x') && utils.__key_in_object(this_config, 'y')) {
-//                 let x = ndframe[this_config['x']].values
-//                 let y = ndframe[this_config['y']].values
-
-//                 let trace = {
-//                     x: x,
-//                     y: y,
-//                     type: config["kind"],
-//                     mode: config["mode"],
-//                 }
-
-//                 let xaxis = {}; let yaxis = {}
-//                 xaxis['title'] = this_config['x']
-//                 yaxis['title'] = this_config['y']
-
-//                 this_config['layout']['xaxis'] = xaxis
-//                 this_config['layout']['yaxis'] = yaxis
-
-
-//                 newPlot(div, [trace], this_config['layout']);
-
-//             } else {
-//                 //plot all
-//                 let y = ndframe.index
-//                 let data = []
-//                 ndframe.column_names.forEach(c_name => {
-//                     let trace = {
-//                         x: ndframe[c_name].values,
-//                         y: y,
-//                         type: this_config["kind"],
-//                         mode: this_config["mode"],
-//                         name: c_name
-//                     };
-//                     data.push(trace)
-
-//                 })
-//                 newPlot(div, data, this_config['layout']);
-//             }
-
-
-//         }
-//     }
-
-// }
+//perform plotting
+import { newPlot } from 'plotly.js/dist/plotly'
+import { Utils } from "../core/utils"
+const utils = new Utils()
+
+
+
+/**
+ * Plotting methods and Functions performed on Series and DataFrames
+ */
+export class Plot {
+    constructor() { }
+
+    plot(ndframe, div, config) {
+        let params = Object.keys(config)
+        let this_config = {}
+
+        if (!utils.__key_in_object(config, "layout")) {
+            this_config['layout'] = {}
+        }
+
+        params.forEach(param => {
+            this_config[param] = config[param]
+        })
+
+        if (ndframe.series) {
+            let x = ndframe.values
+            let trace = {}
+            trace["x"] = x
+
+            params.forEach(param => {
+                if (!param == 'layout') {
+                    trace[param] = config[param]
+                }
+            })
+
+
+            newPlot(div, [trace], this_config['layout']);
+
+        } else {
+            //DataFrame
+            if (utils.__key_in_object(this_config, 'x') && utils.__key_in_object(this_config, 'y')) {
+                let x = ndframe[this_config['x']].values
+                let y = ndframe[this_config['y']].values
+
+                let trace = {
+                    x: x,
+                    y: y,
+                    type: config["type"],
+                    mode: config["mode"],
+                }
+
+                let xaxis = {}; let yaxis = {}
+                xaxis['title'] = this_config['x']
+                yaxis['title'] = this_config['y']
+
+                this_config['layout']['xaxis'] = xaxis
+                this_config['layout']['yaxis'] = yaxis
+
+
+                newPlot(div, [trace], this_config['layout']);
+
+            } else {
+                //plot all
+                let y = ndframe.index
+                let data = []
+                ndframe.column_names.forEach(c_name => {
+                    let trace = {
+                        x: ndframe[c_name].values,
+                        y: y,
+                        type: this_config["type"],
+                        mode: this_config["mode"],
+                        name: c_name
+                    };
+                    data.push(trace)
+
+                })
+                newPlot(div, data, this_config['layout']);
+            }
+
+
+        }
+    }
+
+}

danfojs/tests/core/generic.js

@@ -113,15 +113,15 @@ describe("Generic (NDFrame)", function () {
     describe("NDframe Created from JavaScript Object of Arrays", function () {
 
         it("prints the shape of a 2D ", function () {
-            let data = [{ alpha: ["A", "B", "C", "D"] }, { count: [1, 2, 3, 4] }]
+            let data = { alpha: ["A", "B", "C", "D"], count: [1, 2, 3, 4] }
             let ndframe = new NDframe(data)
             assert.deepEqual(ndframe.shape, [4, 2])
         })
-        // it("prints the shape of a 2D ", function () {
-        //     let data = [{ alpha: ["A", "B", "C", "D"] }, { count: [1,2,3,4]}, {sum: [20.3, 30.456, 40.90, 90.1]}]
-        //     let ndframe = new NDframe(data)
-        //     assert.deepEqual(ndframe.shape, [4, 3])
-        // })
+        it("prints the shape of a 2D ", function () {
+            let data = { alpha: ["A", "B", "C", "D"], count: [1,2,3,4], sum: [20.3, 30.456, 40.90, 90.1]}
+            let ndframe = new NDframe(data)
+            assert.deepEqual(ndframe.shape, [4, 3])
+        })
     })
 
     describe("__set_index", function () {

danfojs/tests/core/utils.js

@@ -175,6 +175,18 @@ describe("Utils Functions", function () {
 
     })
 
+    describe("__get_row_values", function () {
+        it("retreive rows and labels from column object", function () {
+            let data = { "Alpha": ["A", "B", "C", "D"], count: [1,2,3,4], sum: [20.3, 30.456, 40.90, 90.1]}
+            let res = [["A", 1, 20.3], ["B", 2, 30.456], ["C", 3, 40.90], ["D", 4, 90.1]]
+            assert.deepEqual(utils.__get_row_values(data)[0], res)
+            assert.deepEqual(utils.__get_row_values(data)[1], ["Alpha", "count", "sum"])
+
+        })
+        
+
+    })
+