javascriptdata · risenW · Oct 12, 2022 · Jul 18, 2022 · Jul 20, 2022 · Jul 20, 2022
diff --git a/src/danfojs-base/core/frame.ts b/src/danfojs-base/core/frame.ts
@@ -2523,7 +2523,7 @@ export default class DataFrame extends NDframe implements DataFrameInterface {
      * Objects passed to the function are Series values whose 
      * index is either the DataFrame’s index (axis=0) or the DataFrame’s columns (axis=1)
      * @param callable Function to apply to each column or row.
-     * @param options.axis 0 or 1. If 0, compute the power column-wise, if 1, row-wise
+     * @param options.axis 0 or 1. If 0, apply "callable" column-wise, else apply row-wise
      * 
      * @example
      * ```

diff --git a/src/danfojs-base/core/series.ts b/src/danfojs-base/core/series.ts
@@ -1855,8 +1855,8 @@ export default class Series extends NDframe implements SeriesInterface {
     ): Series | void {
         const { inplace } = { inplace: false, ...options }
 
-        if (!newValue && typeof newValue !== "boolean") {
-            throw Error("Param Error: newValues cannot be null or undefined");
+        if (!newValue && typeof newValue !== "boolean" && typeof newValue !== "number") {
+            throw Error("Param Error: newValue cannot be null or undefined");
         }
 
         if (!index) {

diff --git a/src/danfojs-base/io/browser/io.csv.ts b/src/danfojs-base/io/browser/io.csv.ts
@@ -82,7 +82,7 @@ const $streamCSV = async (file: string, callback: (df: DataFrame) => void, optio
   const frameConfig = options?.frameConfig || {}
 
   return new Promise(resolve => {
-    let count = -1
+    let count = 0
     Papa.parse(file, {
       ...options,
       dynamicTyping: true,
@@ -174,4 +174,4 @@ export {
   $readCSV,
   $streamCSV,
   $toCSV,
-}
+}
diff --git a/src/danfojs-base/io/browser/io.excel.ts b/src/danfojs-base/io/browser/io.excel.ts
@@ -49,7 +49,13 @@ import {
  * ```
  */
 const $readExcel = async (file: any, options?: ExcelInputOptionsBrowser) => {
-    const { sheet, method, headers, frameConfig } = { sheet: 0, method: "GET", headers: {}, frameConfig: {}, ...options }
+    const {
+        sheet,
+        method,
+        headers,
+        frameConfig,
+        parsingOptions
+    } = { sheet: 0, method: "GET", headers: {}, frameConfig: {}, parsingOptions: {}, ...options }
 
     if (typeof file === "string" && file.startsWith("http")) {
 
@@ -60,7 +66,7 @@ const $readExcel = async (file: any, options?: ExcelInputOptionsBrowser) => {
                 }
                 response.arrayBuffer().then(arrBuf => {
                     const arrBufInt8 = new Uint8Array(arrBuf);
-                    const workbook = read(arrBufInt8, { type: "array" })
+                    const workbook = read(arrBufInt8, { type: "array", ...parsingOptions });
                     const worksheet = workbook.Sheets[workbook.SheetNames[sheet]];
                     const data = utils.sheet_to_json(worksheet);
                     const df = new DataFrame(data, frameConfig);
@@ -74,7 +80,7 @@ const $readExcel = async (file: any, options?: ExcelInputOptionsBrowser) => {
     } else if (file instanceof File) {
         const arrBuf = await file.arrayBuffer()
         const arrBufInt8 = new Uint8Array(arrBuf);
-        const workbook = read(arrBufInt8, { type: "array" })
+        const workbook = read(arrBufInt8, { type: "array", ...parsingOptions });
         const worksheet = workbook.Sheets[workbook.SheetNames[sheet]];
         const data = utils.sheet_to_json(worksheet);
         const df = new DataFrame(data, frameConfig);
@@ -101,7 +107,11 @@ const $readExcel = async (file: any, options?: ExcelInputOptionsBrowser) => {
  * ```
  */
 const $toExcel = (df: NDframe | DataFrame | Series, options?: ExcelOutputOptionsBrowser) => {
-    let { fileName, sheetName } = { fileName: "./output.xlsx", sheetName: "Sheet1", ...options }
+    let {
+        fileName,
+        sheetName,
+        writingOptions
+    } = { fileName: "./output.xlsx", sheetName: "Sheet1", ...options }
 
     if (!(fileName.endsWith(".xlsx"))) {
         fileName = fileName + ".xlsx"
@@ -121,10 +131,10 @@ const $toExcel = (df: NDframe | DataFrame | Series, options?: ExcelOutputOptions
     const worksheet = utils.aoa_to_sheet(data);
     const wb = utils.book_new();
     utils.book_append_sheet(wb, worksheet, sheetName);
-    writeFile(wb, `${fileName}`)
+    writeFile(wb, `${fileName}`, writingOptions)
 };
 
 export {
     $readExcel,
     $toExcel
-}
+}
diff --git a/src/danfojs-base/io/node/io.csv.ts b/src/danfojs-base/io/node/io.csv.ts
@@ -51,7 +51,7 @@ const $readCSV = async (filePath: string, options?: CsvInputOptionsNode): Promis
   const frameConfig = options?.frameConfig || {}
 
   if (filePath.startsWith("http") || filePath.startsWith("https")) {
-    return new Promise(resolve => {
+    return new Promise((resolve, reject) => {
       const optionsWithDefaults = {
         header: true,
         dynamicTyping: true,
@@ -60,6 +60,13 @@ const $readCSV = async (filePath: string, options?: CsvInputOptionsNode): Promis
       }
 
       const dataStream = request.get(filePath);
+      // reject any non-2xx status codes
+      dataStream.on('response', (response: any) => {
+        if (response.statusCode < 200 || response.statusCode >= 300) {
+          reject(new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`));
+        }
+      });
+
       const parseStream: any = Papa.parse(Papa.NODE_STREAM_INPUT, optionsWithDefaults as any);
       dataStream.pipe(parseStream);
 
@@ -74,17 +81,24 @@ const $readCSV = async (filePath: string, options?: CsvInputOptionsNode): Promis
     });
 
   } else {
-    return new Promise(resolve => {
-      const fileStream = fs.createReadStream(filePath)
-      Papa.parse(fileStream, {
-        header: true,
-        dynamicTyping: true,
-        ...options,
-        complete: results => {
-          const df = new DataFrame(results.data, frameConfig);
-          resolve(df);
+    return new Promise((resolve, reject) => {
+      fs.access(filePath, fs.constants.F_OK, (err) => {
+        if (err) {
+          reject("ENOENT: no such file or directory");
         }
-      });
+
+        const fileStream = fs.createReadStream(filePath)
+
+        Papa.parse(fileStream, {
+          header: true,
+          dynamicTyping: true,
+          ...options,
+          complete: results => {
+            const df = new DataFrame(results.data, frameConfig);
+            resolve(df);
+          }
+        });
+      })
     });
   }
 };
@@ -113,9 +127,17 @@ const $streamCSV = async (filePath: string, callback: (df: DataFrame) => void, o
       dynamicTyping: true,
       ...options,
     }
-    return new Promise(resolve => {
-      let count = -1
+    return new Promise((resolve, reject) => {
+      let count = 0
       const dataStream = request.get(filePath);
+
+      // reject any non-2xx status codes
+      dataStream.on('response', (response: any) => {
+        if (response.statusCode < 200 || response.statusCode >= 300) {
+          reject(new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`));
+        }
+      });
+
       const parseStream: any = Papa.parse(Papa.NODE_STREAM_INPUT, optionsWithDefaults);
       dataStream.pipe(parseStream);
 
@@ -130,19 +152,26 @@ const $streamCSV = async (filePath: string, callback: (df: DataFrame) => void, o
 
     });
   } else {
-    const fileStream = fs.createReadStream(filePath)
 
-    return new Promise(resolve => {
-      let count = -1
-      Papa.parse(fileStream, {
-        header: true,
-        dynamicTyping: true,
-        ...options,
-        step: results => {
-          const df = new DataFrame([results.data], { ...frameConfig, index: [count++] });
-          callback(df);
-        },
-        complete: () => resolve(null)
+    return new Promise((resolve, reject) => {
+      fs.access(filePath, fs.constants.F_OK, (err) => {
+        if (err) {
+          reject("ENOENT: no such file or directory");
+        }
+
+        const fileStream = fs.createReadStream(filePath)
+
+        let count = 0
+        Papa.parse(fileStream, {
+          header: true,
+          dynamicTyping: true,
+          ...options,
+          step: results => {
+            const df = new DataFrame([results.data], { ...frameConfig, index: [count++] });
+            callback(df);
+          },
+          complete: () => resolve(null)
+        });
       });
     });
   }
@@ -228,9 +257,17 @@ const $openCsvInputStream = (filePath: string, options: CsvInputOptionsNode) =>
 
   if (filePath.startsWith("http") || filePath.startsWith("https")) {
     const dataStream = request.get(filePath);
+
+    // reject any non-2xx status codes
+    dataStream.on('response', (response: any) => {
+      if (response.statusCode < 200 || response.statusCode >= 300) {
+        throw new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`);
+      }
+    });
+
     const parseStream: any = Papa.parse(Papa.NODE_STREAM_INPUT, { header, dynamicTyping: true, ...options });
     dataStream.pipe(parseStream);
-    let count = -1
+    let count = 0
 
     parseStream.on("data", (chunk: any) => {
       if (isFirstChunk) {
@@ -258,37 +295,44 @@ const $openCsvInputStream = (filePath: string, options: CsvInputOptionsNode) =>
     return csvInputStream;
   } else {
     const fileStream = fs.createReadStream(filePath)
-    let count = -1
-    Papa.parse(fileStream, {
-      ...{ header, dynamicTyping: true, ...options },
-      step: results => {
-        if (isFirstChunk) {
-          if (header === true) {
-            ndFrameColumnNames = results.meta.fields || []
-          } else {
-            ndFrameColumnNames = results.data
+
+    fs.access(filePath, fs.constants.F_OK, (err) => {
+      if (err) {
+        throw new Error("ENOENT: no such file or directory");
+      }
+
+      let count = 0
+      Papa.parse(fileStream, {
+        ...{ header, dynamicTyping: true, ...options },
+        step: results => {
+          if (isFirstChunk) {
+            if (header === true) {
+              ndFrameColumnNames = results.meta.fields || []
+            } else {
+              ndFrameColumnNames = results.data
+            }
+            isFirstChunk = false
+            return
           }
-          isFirstChunk = false
-          return
+
+          const df = new DataFrame([results.data], {
+            columns: ndFrameColumnNames,
+            index: [count++]
+          })
+
+          csvInputStream.push(df);
+        },
+        complete: (result: any) => {
+          csvInputStream.push(null);
+          return null
+        },
+        error: (err) => {
+          csvInputStream.emit("error", err);
         }
+      });
 
-        const df = new DataFrame([results.data], {
-          columns: ndFrameColumnNames,
-          index: [count++]
-        })
-
-        csvInputStream.push(df);
-      },
-      complete: (result: any) => {
-        csvInputStream.push(null);
-        return null
-      },
-      error: (err) => {
-        csvInputStream.emit("error", err);
-      }
+      return csvInputStream;
     });
-
-    return csvInputStream;
   }
 };
 
@@ -314,39 +358,45 @@ const $openCsvInputStream = (filePath: string, options: CsvInputOptionsNode) =>
  * ```
  */
 const $writeCsvOutputStream = (filePath: string, options: CsvInputOptionsNode) => {
-  let isFirstRow = true
-  const fileOutputStream = fs.createWriteStream(filePath)
-  const csvOutputStream = new stream.Writable({ objectMode: true })
+  fs.access(filePath, fs.constants.F_OK, (err) => {
+    if (err) {
+      throw new Error("ENOENT: no such file or directory");
+    }
+
+    let isFirstRow = true
+    const fileOutputStream = fs.createWriteStream(filePath)
+    const csvOutputStream = new stream.Writable({ objectMode: true })
 
-  csvOutputStream._write = (chunk: DataFrame | Series, encoding, callback) => {
+    csvOutputStream._write = (chunk: DataFrame | Series, encoding, callback) => {
 
-    if (chunk instanceof DataFrame) {
+      if (chunk instanceof DataFrame) {
 
-      if (isFirstRow) {
-        isFirstRow = false
-        fileOutputStream.write($toCSV(chunk, { header: true, ...options }));
+        if (isFirstRow) {
+          isFirstRow = false
+          fileOutputStream.write($toCSV(chunk, { header: true, ...options }));
+          callback();
+        } else {
+          fileOutputStream.write($toCSV(chunk, { header: false, ...options }));
+          callback();
+        }
+
+      } else if (chunk instanceof Series) {
+
+        fileOutputStream.write($toCSV(chunk));
         callback();
+
       } else {
-        fileOutputStream.write($toCSV(chunk, { header: false, ...options }));
-        callback();
+        csvOutputStream.emit("error", new Error("ValueError: Intermediate chunk must be either a Series or DataFrame"))
       }
 
-    } else if (chunk instanceof Series) {
-
-      fileOutputStream.write($toCSV(chunk));
-      callback();
-
-    } else {
-      csvOutputStream.emit("error", new Error("ValueError: Intermediate chunk must be either a Series or DataFrame"))
     }
 
-  }
-
-  csvOutputStream.on("finish", () => {
-    fileOutputStream.end()
-  })
+    csvOutputStream.on("finish", () => {
+      fileOutputStream.end()
+    })
 
-  return csvOutputStream
+    return csvOutputStream
+  });
 }
 
 
@@ -358,4 +408,4 @@ export {
   $toCSV,
   $writeCsvOutputStream,
   $openCsvInputStream,
-}
+}