Merge branch 'main' of github.com:pola-rs/nodejs-polars into nodejs-p…

…olars-v0.16.0

.github/workflows/docs.yaml

@@ -14,7 +14,7 @@ jobs:
       - name: Install latest Rust nightly
         uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: nightly-2024-08-26
+          toolchain: nightly-2024-09-19
           components: rustfmt, clippy
       - name: Install ghp-import
         uses: actions/setup-python@v5

.github/workflows/test-js.yaml

@@ -20,7 +20,7 @@ jobs:
       - name: Install latest Rust nightly
         uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: nightly-2024-08-26
+          toolchain: nightly-2024-09-19
           components: rustfmt, clippy
       - name: Check yarn version
         run: yarn --version
@@ -46,7 +46,7 @@ jobs:
       - name: Install latest Rust nightly
         uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: nightly-2024-08-26
+          toolchain: nightly-2024-09-19
           components: rustfmt, clippy
       - name: Bun version
         uses: oven-sh/setup-bun@v1

__tests__/dataframe.test.ts

@@ -1,7 +1,7 @@
+import fs from "node:fs";
+import { Stream } from "node:stream";
 /* eslint-disable newline-per-chained-call */
 import pl from "@polars";
-import { Stream } from "stream";
-import fs from "fs";
 describe("dataframe", () => {
   const df = pl.DataFrame([
     pl.Series("foo", [1, 2, 9], pl.Int16),
@@ -338,24 +338,30 @@ describe("dataframe", () => {
     const actual = df.fold((a, b) => a.concat(b));
     expect(actual).toSeriesEqual(expected);
   });
-  // test("fold", () => {
-  //   const s1 = pl.Series([1, 2, 3]);
-  //   const s2 = pl.Series([4, 5, 6]);
-  //   const s3 = pl.Series([7, 8, 1]);
-  //   const expected = pl.Series("foo", [true, true, false]);
-  //   const df = pl.DataFrame([s1, s2, s3]);
-  //   const actual = df.fold((a, b) => a.lessThan(b)).alias("foo");
-  //   expect(actual).toSeriesEqual(expected);
-  // });
-  // test("fold-again", () => {
-  //   const s1 = pl.Series([1, 2, 3]);
-  //   const s2 = pl.Series([4, 5, 6]);
-  //   const s3 = pl.Series([7, 8, 1]);
-  //   const expected = pl.Series("foo", [12, 15, 10]);
-  //   const df = pl.DataFrame([s1, s2, s3]);
-  //   const actual = df.fold((a, b) => a.plus(b)).alias("foo");
-  //   expect(actual).toSeriesEqual(expected);
-  // });
+  it.each`
+    name                     | actual                                                 | expected
+    ${"fold:lessThan"}       | ${df.fold((a, b) => a.lessThan(b)).alias("foo")}       | ${pl.Series("foo", [true, false, false])}
+    ${"fold:lt"}             | ${df.fold((a, b) => a.lt(b)).alias("foo")}             | ${pl.Series("foo", [true, false, false])}
+    ${"fold:lessThanEquals"} | ${df.fold((a, b) => a.lessThanEquals(b)).alias("foo")} | ${pl.Series("foo", [true, true, false])}
+    ${"fold:ltEq"}           | ${df.fold((a, b) => a.ltEq(b)).alias("foo")}           | ${pl.Series("foo", [true, true, false])}
+    ${"fold:neq"}            | ${df.fold((a, b) => a.neq(b)).alias("foo")}            | ${pl.Series("foo", [true, false, true])}
+    ${"fold:plus"}           | ${df.fold((a, b) => a.plus(b)).alias("foo")}           | ${pl.Series("foo", [7, 4, 17])}
+    ${"fold:minus"}          | ${df.fold((a, b) => a.minus(b)).alias("foo")}          | ${pl.Series("foo", [-5, 0, 1])}
+    ${"fold:mul"}            | ${df.fold((a, b) => a.mul(b)).alias("foo")}            | ${pl.Series("foo", [6, 4, 72])}
+  `("$# $name expected matches actual", ({ expected, actual }) => {
+    expect(expected).toSeriesEqual(actual);
+  });
+  test("fold:lt", () => {
+    const s1 = pl.Series([1, 2, 3]);
+    const s2 = pl.Series([4, 5, 6]);
+    const s3 = pl.Series([7, 8, 1]);
+    const df = pl.DataFrame([s1, s2, s3]);
+    const expected = pl.Series("foo", [true, true, false]);
+    let actual = df.fold((a, b) => a.lessThan(b)).alias("foo");
+    expect(actual).toSeriesEqual(expected);
+    actual = df.fold((a, b) => a.lt(b)).alias("foo");
+    expect(actual).toSeriesEqual(expected);
+  });
   test("frameEqual:true", () => {
     const df = pl.DataFrame({
       foo: [1, 2, 3],

__tests__/io.test.ts

@@ -1,7 +1,7 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Stream } from "node:stream";
 import pl from "@polars";
-import path from "path";
-import { Stream } from "stream";
-import fs from "fs";
 // eslint-disable-next-line no-undef
 const csvpath = path.resolve(__dirname, "./examples/datasets/foods1.csv");
 // eslint-disable-next-line no-undef

__tests__/lazyframe.test.ts

@@ -1,5 +1,5 @@
+import fs from "node:fs";
 import pl from "@polars";
-import fs from "fs";
 
 describe("lazyframe", () => {
   test("columns", () => {

__tests__/serde.test.ts

@@ -1,5 +1,5 @@
+import path from "node:path";
 import pl from "@polars";
-import path from "path";
 // eslint-disable-next-line no-undef
 const csvpath = path.resolve(__dirname, "./examples/datasets/foods1.csv");
 describe("serde", () => {

biome.json

@@ -1,15 +1,11 @@
 {
-  "$schema": "https://biomejs.dev/schemas/1.8.3/schema.json",
-  "organizeImports": {
-    "enabled": false
-  },
+  "$schema": "https://biomejs.dev/schemas/1.9.2/schema.json",
   "linter": {
     "enabled": true,
     "rules": {
       "recommended": true,
       "style": {
-        "noParameterAssign": "off",
-        "useNodejsImportProtocol": "off"
+        "noParameterAssign": "off"
       },
       "suspicious": {
         "noExplicitAny": "off",

package.json

@@ -54,11 +54,11 @@
     "precommit": "yarn lint && yarn test"
   },
   "devDependencies": {
-    "@biomejs/biome": "=1.8.3",
+    "@biomejs/biome": "=1.9.2",
     "@napi-rs/cli": "^2.18.4",
     "@types/chance": "^1.1.6",
-    "@types/jest": "^29.5.12",
-    "@types/node": "^22.5.4",
+    "@types/jest": "^29.5.13",
+    "@types/node": "^22.5.5",
     "chance": "^1.1.12",
     "jest": "^29.7.0",
     "source-map-support": "^0.5.21",

polars/dataframe.ts

@@ -1,16 +1,16 @@
-import pli from "./internals/polars_internal";
-import { arrayToJsDataFrame } from "./internals/construction";
+import { Stream, Writable } from "node:stream";
+import { concat } from "./functions";
 import {
-  _GroupBy,
   DynamicGroupBy,
   type GroupBy,
   RollingGroupBy,
+  _GroupBy,
 } from "./groupby";
-import { _LazyDataFrame, type LazyDataFrame } from "./lazy/dataframe";
-import { concat } from "./functions";
+import { arrayToJsDataFrame } from "./internals/construction";
+import pli from "./internals/polars_internal";
+import { type LazyDataFrame, _LazyDataFrame } from "./lazy/dataframe";
 import { Expr } from "./lazy/expr";
-import { _Series, Series } from "./series";
-import { Stream, Writable } from "stream";
+import { Series, _Series } from "./series";
 import type {
   FillNullStrategy,
   JoinOptions,
@@ -23,13 +23,13 @@ import type {
 import { DataType } from "./datatypes";
 
 import {
-  columnOrColumns,
-  columnOrColumnsStrict,
   type ColumnSelection,
   type ColumnsOrExpr,
   type ExprOrString,
-  isSeriesArray,
   type ValueOrArray,
+  columnOrColumns,
+  columnOrColumnsStrict,
+  isSeriesArray,
 } from "./utils";
 
 import type {

polars/functions.ts

@@ -1,11 +1,11 @@
+import { type DataFrame, _DataFrame } from "./dataframe";
 /* eslint-disable no-redeclare */
 import { jsTypeToPolarsType } from "./internals/construction";
-import { type Series, _Series } from "./series";
-import { type DataFrame, _DataFrame } from "./dataframe";
-import { type LazyDataFrame, _LazyDataFrame } from "./lazy/dataframe";
 import pli from "./internals/polars_internal";
-import { isDataFrameArray, isLazyDataFrameArray, isSeriesArray } from "./utils";
+import { type LazyDataFrame, _LazyDataFrame } from "./lazy/dataframe";
+import { type Series, _Series } from "./series";
 import type { ConcatOptions } from "./types";
+import { isDataFrameArray, isLazyDataFrameArray, isSeriesArray } from "./utils";
 
 /**
  * _Repeat a single value n times and collect into a Series._

polars/groupby.ts

@@ -1,8 +1,8 @@
+import util from "node:util";
 import { type DataFrame, _DataFrame } from "./dataframe";
-import * as utils from "./utils";
-import util from "util";
 import type { Expr } from "./lazy/expr";
 import { col, exclude } from "./lazy/functions";
+import * as utils from "./utils";
 import type { ColumnsOrExpr, StartBy } from "./utils";
 
 const inspect = Symbol.for("nodejs.util.inspect.custom");

polars/index.ts

@@ -1,12 +1,12 @@
-import * as series from "./series";
 import * as df from "./dataframe";
 import { DataType, Field as _field } from "./datatypes";
+import * as series from "./series";
 export { DataType } from "./datatypes";
+import * as cfg from "./cfg";
 import * as func from "./functions";
+import pli from "./internals/polars_internal";
 import * as io from "./io";
-import * as cfg from "./cfg";
 import * as ldf from "./lazy/dataframe";
-import pli from "./internals/polars_internal";
 export * from "./series";
 export * from "./dataframe";
 export * from "./functions";

polars/internals/construction.ts

@@ -1,10 +1,10 @@
-import pli from "./polars_internal";
-import { DataType, polarsTypeToConstructor } from "../datatypes";
-import { isTypedArray } from "util/types";
-import { Series } from "../series";
+import { isTypedArray } from "node:util/types";
 import { _DataFrame } from "../dataframe";
+import { DataType, polarsTypeToConstructor } from "../datatypes";
 import { FixedSizeList, TimeUnit } from "../datatypes/datatype";
 import { Field } from "../datatypes/field";
+import { Series } from "../series";
+import pli from "./polars_internal";
 
 export const jsTypeToPolarsType = (value: unknown): DataType => {
   if (value === null) {

polars/io.ts

@@ -1,11 +1,11 @@
+import { type Readable, Stream } from "node:stream";
+import { type DataFrame, _DataFrame } from "./dataframe";
 import type { DataType } from "./datatypes";
+import { concat } from "./functions";
 import pli from "./internals/polars_internal";
-import { type DataFrame, _DataFrame } from "./dataframe";
-import { isPath } from "./utils";
 import { type LazyDataFrame, _LazyDataFrame } from "./lazy/dataframe";
-import { type Readable, Stream } from "stream";
-import { concat } from "./functions";
-import type { ScanParquetOptions, RowCount } from "./types";
+import type { RowCount, ScanParquetOptions } from "./types";
+import { isPath } from "./utils";
 
 export interface ReadCsvOptions {
   inferSchemaLength: number | null;

polars/lazy/dataframe.ts

@@ -1,23 +1,23 @@
 import { type DataFrame, _DataFrame } from "../dataframe";
-import { Expr, exprToLitOrExpr } from "./expr";
 import pli from "../internals/polars_internal";
-import {
-  columnOrColumnsStrict,
-  type ColumnSelection,
-  type ColumnsOrExpr,
-  type ExprOrString,
-  selectionToExprList,
-  type ValueOrArray,
-} from "../utils";
-import { _LazyGroupBy, type LazyGroupBy } from "./groupby";
+import type { Series } from "../series";
 import type { Deserialize, GroupByOps, Serialize } from "../shared_traits";
 import type {
-  LazyOptions,
   LazyJoinOptions,
+  LazyOptions,
   SinkCsvOptions,
   SinkParquetOptions,
 } from "../types";
-import type { Series } from "../series";
+import {
+  type ColumnSelection,
+  type ColumnsOrExpr,
+  type ExprOrString,
+  type ValueOrArray,
+  columnOrColumnsStrict,
+  selectionToExprList,
+} from "../utils";
+import { Expr, exprToLitOrExpr } from "./expr";
+import { type LazyGroupBy, _LazyGroupBy } from "./groupby";
 
 const inspect = Symbol.for("nodejs.util.inspect.custom");
 

polars/lazy/expr/index.ts

@@ -7,32 +7,32 @@ export type { ExprList as ListNamespace } from "./list";
 export type { ExprDateTime as DatetimeNamespace } from "./datetime";
 export type { ExprStruct as StructNamespace } from "./struct";
 
+import { isRegExp } from "node:util/types";
 import type { DataType } from "../../datatypes";
 import pli from "../../internals/polars_internal";
-import {
-  type ExprOrString,
-  selectionToExprList,
-  INSPECT_SYMBOL,
-  regexToString,
-} from "../../utils";
 import { Series } from "../../series";
 import type {
   Arithmetic,
   Comparison,
   Cumulative,
   Deserialize,
+  EwmOps,
   Rolling,
   Round,
   Sample,
   Serialize,
-  EwmOps,
 } from "../../shared_traits";
 import type {
-  InterpolationMethod,
   FillNullStrategy,
+  InterpolationMethod,
   RankMethod,
 } from "../../types";
-import { isRegExp } from "util/types";
+import {
+  type ExprOrString,
+  INSPECT_SYMBOL,
+  regexToString,
+  selectionToExprList,
+} from "../../utils";
 /**
  * Expressions that can be used in various contexts.
  */

polars/lazy/expr/list.ts

@@ -1,7 +1,7 @@
-import { Expr, _Expr, exprToLitOrExpr } from "../expr";
-import type { ListFunctions } from "../../shared_traits";
-import { Series } from "../../series";
 import pli from "../../internals/polars_internal";
+import { Series } from "../../series";
+import type { ListFunctions } from "../../shared_traits";
+import { Expr, _Expr, exprToLitOrExpr } from "../expr";
 import { concatList } from "../functions";
 
 /**

polars/lazy/expr/string.ts

@@ -1,5 +1,5 @@
-import type { StringFunctions } from "../../shared_traits";
 import { DataType } from "../../datatypes";
+import type { StringFunctions } from "../../shared_traits";
 import { regexToString } from "../../utils";
 import { Expr, _Expr, exprToLitOrExpr } from "../expr";
 import { lit } from "../functions";

polars/lazy/expr/struct.ts

@@ -1,4 +1,4 @@
-import { _Expr, type Expr } from "../expr";
+import { type Expr, _Expr } from "../expr";
 
 /**
  * Struct functions

polars/lazy/functions.ts

@@ -1,9 +1,9 @@
-import { Expr, _Expr, exprToLitOrExpr } from "./expr";
+import { DataFrame } from "../dataframe";
 import { DataType } from "../datatypes";
+import pli from "../internals/polars_internal";
 import { Series } from "../series";
-import { DataFrame } from "../dataframe";
 import { type ExprOrString, range, selectionToExprList } from "../utils";
-import pli from "../internals/polars_internal";
+import { Expr, _Expr, exprToLitOrExpr } from "./expr";
 
 /**
  * __A column in a DataFrame.__

polars/lazy/groupby.ts

@@ -1,6 +1,6 @@
-import type { Expr } from "./expr";
 import { selectionToExprList } from "../utils";
-import { _LazyDataFrame, type LazyDataFrame } from "./dataframe";
+import { type LazyDataFrame, _LazyDataFrame } from "./dataframe";
+import type { Expr } from "./expr";
 
 /** @ignore */
 export const _LazyGroupBy = (_lgb: any): LazyGroupBy => {

polars/lazy/whenthen.ts

@@ -1,5 +1,5 @@
-import { Expr } from "./expr";
 import pli from "../internals/polars_internal";
+import { Expr } from "./expr";
 
 export interface When {
   /** Values to return in case of the predicate being `true`.*/