@ohos-ports/nodejs-polars 0.22.2-beta.0

package/bin/index.js

@@ -0,0 +1,265 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anyHorizontal = exports.allHorizontal = exports.struct = exports.select = exports.quantile = exports.pearsonCorr = exports.nUnique = exports.median = exports.mean = exports.last = exports.head = exports.groups = exports.format = exports.first = exports.element = exports.exclude = exports.cov = exports.count = exports.concatString = exports.concatList = exports.avg = exports.argSortBy = exports.intRanges = exports.intRange = exports.lit = exports.cols = exports.col = exports.readJSONStream = exports.readCSVStream = exports.readAvro = exports.readParquet = exports.readJSON = exports.readIPCStream = exports.readIPC = exports.readCSV = exports.readRecords = exports.scanParquet = exports.scanIPC = exports.scanJson = exports.scanCSV = exports.concat = exports.repeat = exports.Field = exports.Config = exports.Series = exports.LazyDataFrame = exports.DataFrame = exports.Expr = exports.pl = exports.DataType = void 0;
+exports.Decimal = exports.Struct = exports.Null = exports.Object = exports.Time = exports.Datetime = exports.Date = exports.FixedSizeList = exports.List = exports.String = exports.Utf8 = exports.Bool = exports.Float64 = exports.Float32 = exports.UInt64 = exports.UInt32 = exports.UInt16 = exports.UInt8 = exports.Int64 = exports.Int32 = exports.Int16 = exports.Int8 = exports.Categorical = exports.version = exports.when = exports.list = exports.tail = exports.spearmanRankCorr = exports.sumHorizontal = exports.maxHorizontal = exports.minHorizontal = void 0;
+exports.SQLContext = SQLContext;
+const df = __importStar(require("./dataframe"));
+const datatypes_1 = require("./datatypes");
+const series = __importStar(require("./series"));
+var datatypes_2 = require("./datatypes");
+Object.defineProperty(exports, "DataType", { enumerable: true, get: function () { return datatypes_2.DataType; } });
+const cfg = __importStar(require("./cfg"));
+const func = __importStar(require("./functions"));
+const polars_internal_1 = __importDefault(require("./internals/polars_internal"));
+const io = __importStar(require("./io"));
+const ldf = __importStar(require("./lazy/dataframe"));
+__exportStar(require("./cfg"), exports);
+__exportStar(require("./dataframe"), exports);
+__exportStar(require("./functions"), exports);
+__exportStar(require("./io"), exports);
+__exportStar(require("./lazy"), exports);
+__exportStar(require("./lazy/dataframe"), exports);
+__exportStar(require("./series"), exports);
+const lazy = __importStar(require("./lazy"));
+__exportStar(require("./types"), exports);
+const sql = __importStar(require("./sql"));
+var pl;
+(function (pl) {
+    pl.Expr = lazy.Expr;
+    pl.DataFrame = df.DataFrame;
+    pl.LazyDataFrame = ldf.LazyDataFrame;
+    pl.Series = series.Series;
+    pl.Config = cfg.Config;
+    pl.Field = datatypes_1.Field;
+    pl.repeat = func.repeat;
+    pl.concat = func.concat;
+    // IO
+    pl.scanCSV = io.scanCSV;
+    pl.scanJson = io.scanJson;
+    pl.scanIPC = io.scanIPC;
+    pl.scanParquet = io.scanParquet;
+    pl.readRecords = io.readRecords;
+    pl.readCSV = io.readCSV;
+    pl.readIPC = io.readIPC;
+    pl.readIPCStream = io.readIPCStream;
+    pl.readJSON = io.readJSON;
+    pl.readParquet = io.readParquet;
+    pl.readAvro = io.readAvro;
+    pl.readCSVStream = io.readCSVStream;
+    pl.readJSONStream = io.readJSONStream;
+    // lazy
+    pl.col = lazy.col;
+    pl.nth = lazy.nth;
+    pl.cols = lazy.cols;
+    pl.lit = lazy.lit;
+    pl.intRange = lazy.intRange;
+    pl.intRanges = lazy.intRanges;
+    pl.argSortBy = lazy.argSortBy;
+    pl.avg = lazy.avg;
+    pl.concatList = lazy.concatList;
+    pl.concatString = lazy.concatString;
+    pl.count = lazy.count;
+    pl.cov = lazy.cov;
+    pl.exclude = lazy.exclude;
+    pl.element = lazy.element;
+    pl.first = lazy.first;
+    pl.format = lazy.format;
+    pl.groups = lazy.groups;
+    pl.head = lazy.head;
+    pl.last = lazy.last;
+    pl.len = lazy.len;
+    pl.mean = lazy.mean;
+    pl.median = lazy.median;
+    pl.nUnique = lazy.nUnique;
+    pl.pearsonCorr = lazy.pearsonCorr;
+    pl.quantile = lazy.quantile;
+    pl.select = lazy.select;
+    pl.struct = lazy.struct;
+    pl.allHorizontal = lazy.allHorizontal;
+    pl.anyHorizontal = lazy.anyHorizontal;
+    pl.minHorizontal = lazy.minHorizontal;
+    pl.maxHorizontal = lazy.maxHorizontal;
+    pl.sumHorizontal = lazy.sumHorizontal;
+    pl.spearmanRankCorr = lazy.spearmanRankCorr;
+    pl.tail = lazy.tail;
+    pl.list = lazy.list;
+    pl.when = lazy.when;
+    pl.version = polars_internal_1.default.version();
+    pl.Categorical = datatypes_1.DataType.Categorical;
+    pl.Int8 = datatypes_1.DataType.Int8;
+    pl.Int16 = datatypes_1.DataType.Int16;
+    pl.Int32 = datatypes_1.DataType.Int32;
+    pl.Int64 = datatypes_1.DataType.Int64;
+    pl.UInt8 = datatypes_1.DataType.UInt8;
+    pl.UInt16 = datatypes_1.DataType.UInt16;
+    pl.UInt32 = datatypes_1.DataType.UInt32;
+    pl.UInt64 = datatypes_1.DataType.UInt64;
+    pl.Float32 = datatypes_1.DataType.Float32;
+    pl.Float64 = datatypes_1.DataType.Float64;
+    pl.Bool = datatypes_1.DataType.Bool;
+    pl.Utf8 = datatypes_1.DataType.Utf8;
+    // biome-ignore lint/suspicious/noShadowRestrictedNames: pl.String
+    pl.String = datatypes_1.DataType.String;
+    pl.List = datatypes_1.DataType.List;
+    pl.FixedSizeList = datatypes_1.DataType.FixedSizeList;
+    // biome-ignore lint/suspicious/noShadowRestrictedNames: pl.Date
+    pl.Date = datatypes_1.DataType.Date;
+    pl.Datetime = datatypes_1.DataType.Datetime;
+    pl.Time = datatypes_1.DataType.Time;
+    // biome-ignore lint/suspicious/noShadowRestrictedNames: pl.Object
+    pl.Object = datatypes_1.DataType.Object;
+    pl.Null = datatypes_1.DataType.Null;
+    pl.Struct = datatypes_1.DataType.Struct;
+    pl.Decimal = datatypes_1.DataType.Decimal;
+    /**
+     * Run SQL queries against DataFrame/LazyFrame data.
+     *
+     * @experimental This functionality is considered **unstable**, although it is close to being
+     * considered stable. It may be changed at any point without it being considered a breaking change.
+     */
+    function SQLContext(frames) {
+        return new sql.SQLContext(frames);
+    }
+    pl.SQLContext = SQLContext;
+})(pl || (exports.pl = pl = {}));
+exports.default = pl;
+// ------
+// CommonJS compatibility.
+// This allows the user to use any of the following
+// `import * as pl from "nodejs-polars"`
+// `import pl from "nodejs-polars"`.
+// `const pl = require("nodejs-polars")`.
+// `const { DataFrame, Series, } = require("nodejs-polars")`.
+// ------
+exports.Expr = lazy.Expr;
+exports.DataFrame = df.DataFrame;
+exports.LazyDataFrame = ldf.LazyDataFrame;
+exports.Series = series.Series;
+exports.Config = cfg.Config;
+exports.Field = datatypes_1.Field;
+exports.repeat = func.repeat;
+exports.concat = func.concat;
+// IO
+exports.scanCSV = io.scanCSV;
+exports.scanJson = io.scanJson;
+exports.scanIPC = io.scanIPC;
+exports.scanParquet = io.scanParquet;
+exports.readRecords = io.readRecords;
+exports.readCSV = io.readCSV;
+exports.readIPC = io.readIPC;
+exports.readIPCStream = io.readIPCStream;
+exports.readJSON = io.readJSON;
+exports.readParquet = io.readParquet;
+exports.readAvro = io.readAvro;
+exports.readCSVStream = io.readCSVStream;
+exports.readJSONStream = io.readJSONStream;
+// lazy
+exports.col = lazy.col;
+exports.cols = lazy.cols;
+exports.lit = lazy.lit;
+exports.intRange = lazy.intRange;
+exports.intRanges = lazy.intRanges;
+exports.argSortBy = lazy.argSortBy;
+exports.avg = lazy.avg;
+exports.concatList = lazy.concatList;
+exports.concatString = lazy.concatString;
+exports.count = lazy.count;
+exports.cov = lazy.cov;
+exports.exclude = lazy.exclude;
+exports.element = lazy.element;
+exports.first = lazy.first;
+exports.format = lazy.format;
+exports.groups = lazy.groups;
+exports.head = lazy.head;
+exports.last = lazy.last;
+exports.mean = lazy.mean;
+exports.median = lazy.median;
+exports.nUnique = lazy.nUnique;
+exports.pearsonCorr = lazy.pearsonCorr;
+exports.quantile = lazy.quantile;
+exports.select = lazy.select;
+exports.struct = lazy.struct;
+exports.allHorizontal = lazy.allHorizontal;
+exports.anyHorizontal = lazy.anyHorizontal;
+exports.minHorizontal = lazy.minHorizontal;
+exports.maxHorizontal = lazy.maxHorizontal;
+exports.sumHorizontal = lazy.sumHorizontal;
+exports.spearmanRankCorr = lazy.spearmanRankCorr;
+exports.tail = lazy.tail;
+exports.list = lazy.list;
+exports.when = lazy.when;
+exports.version = polars_internal_1.default.version();
+exports.Categorical = datatypes_1.DataType.Categorical;
+exports.Int8 = datatypes_1.DataType.Int8;
+exports.Int16 = datatypes_1.DataType.Int16;
+exports.Int32 = datatypes_1.DataType.Int32;
+exports.Int64 = datatypes_1.DataType.Int64;
+exports.UInt8 = datatypes_1.DataType.UInt8;
+exports.UInt16 = datatypes_1.DataType.UInt16;
+exports.UInt32 = datatypes_1.DataType.UInt32;
+exports.UInt64 = datatypes_1.DataType.UInt64;
+exports.Float32 = datatypes_1.DataType.Float32;
+exports.Float64 = datatypes_1.DataType.Float64;
+exports.Bool = datatypes_1.DataType.Bool;
+exports.Utf8 = datatypes_1.DataType.Utf8;
+// biome-ignore lint/suspicious/noShadowRestrictedNames: pl.String
+exports.String = datatypes_1.DataType.String;
+exports.List = datatypes_1.DataType.List;
+exports.FixedSizeList = datatypes_1.DataType.FixedSizeList;
+// biome-ignore lint/suspicious/noShadowRestrictedNames: pl.Date
+exports.Date = datatypes_1.DataType.Date;
+exports.Datetime = datatypes_1.DataType.Datetime;
+exports.Time = datatypes_1.DataType.Time;
+// biome-ignore lint/suspicious/noShadowRestrictedNames: pl.Object
+exports.Object = datatypes_1.DataType.Object;
+exports.Null = datatypes_1.DataType.Null;
+exports.Struct = datatypes_1.DataType.Struct;
+exports.Decimal = datatypes_1.DataType.Decimal;
+/**
+ * Run SQL queries against DataFrame/LazyFrame data.
+ *
+ * @experimental This functionality is considered **unstable**, although it is close to being
+ * considered stable. It may be changed at any point without it being considered a breaking change.
+ */
+function SQLContext(frames) {
+    return new sql.SQLContext(frames);
+}

package/bin/internals/construction.d.ts

@@ -0,0 +1,7 @@
+import { DataType } from "../datatypes";
+export declare const jsTypeToPolarsType: (value: unknown) => DataType;
+/**
+ * Construct an internal `JsSeries` from an array
+ */
+export declare function arrayToJsSeries(name?: string, values?: any[], dtype?: DataType): any;
+export declare function arrayToJsDataFrame(data: any[], options?: any): any;

package/bin/internals/construction.js

@@ -0,0 +1,237 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsTypeToPolarsType = void 0;
+exports.arrayToJsSeries = arrayToJsSeries;
+exports.arrayToJsDataFrame = arrayToJsDataFrame;
+const types_1 = require("node:util/types");
+const datatypes_1 = require("../datatypes");
+const datatype_1 = require("../datatypes/datatype");
+const field_1 = require("../datatypes/field");
+const series_1 = require("../series");
+const polars_internal_1 = __importDefault(require("./polars_internal"));
+const jsTypeToPolarsType = (value) => {
+    if (value === null) {
+        return datatypes_1.DataType.Float64;
+    }
+    if (Array.isArray(value)) {
+        return (0, exports.jsTypeToPolarsType)(firstNonNull(value));
+    }
+    if ((0, types_1.isTypedArray)(value)) {
+        switch (value.constructor.name) {
+            case Int8Array.name:
+                return datatypes_1.DataType.Int8;
+            case Int16Array.name:
+                return datatypes_1.DataType.Int16;
+            case Int32Array.name:
+                return datatypes_1.DataType.Int32;
+            case BigInt64Array.name:
+                return datatypes_1.DataType.Int64;
+            case Uint8Array.name:
+                return datatypes_1.DataType.UInt8;
+            case Uint16Array.name:
+                return datatypes_1.DataType.UInt16;
+            case Uint32Array.name:
+                return datatypes_1.DataType.UInt32;
+            case BigUint64Array.name:
+                return datatypes_1.DataType.UInt64;
+            case Float32Array.name:
+                return datatypes_1.DataType.Float32;
+            case Float64Array.name:
+                return datatypes_1.DataType.Float64;
+            default:
+                throw new Error(`unknown  typed array type: ${value.constructor.name}`);
+        }
+    }
+    if (value instanceof Date) {
+        return datatypes_1.DataType.Datetime(datatype_1.TimeUnit.Milliseconds);
+    }
+    if (typeof value === "object" && value.constructor === Object) {
+        const flds = Object.entries(value).map(([name, value]) => {
+            const dtype = (0, exports.jsTypeToPolarsType)(value);
+            return field_1.Field.from(name, dtype);
+        });
+        return datatypes_1.DataType.Struct(flds);
+    }
+    switch (typeof value) {
+        case "bigint":
+            return datatypes_1.DataType.UInt64;
+        case "number":
+            return datatypes_1.DataType.Float64;
+        case "string":
+            return datatypes_1.DataType.Utf8;
+        case "boolean":
+            return datatypes_1.DataType.Bool;
+        default:
+            return datatypes_1.DataType.Float64;
+    }
+};
+exports.jsTypeToPolarsType = jsTypeToPolarsType;
+/**
+ * __finds the first non null value in the inputs__
+ * ___
+ * If the first value is an array
+ * it will find the first scalar type in the array and return it wrapped into the array
+ *
+ * @example
+ * ```
+ * > const input = [null, [], [null, "a", "b"]]
+ * > firstNonNull(input)
+ * ["a"]
+ * > const ints = [null, 1]
+ * > firstNonNull(ints)
+ * 1
+ * ```
+ */
+const firstNonNull = (arr) => {
+    const first = arr.find((x) => x !== null && x !== undefined);
+    if (Array.isArray(first)) {
+        return [firstNonNull(arr.flat())];
+    }
+    return first;
+};
+const fromTypedArray = (name, value) => {
+    switch (value.constructor.name) {
+        case Int8Array.name:
+            return polars_internal_1.default.JsSeries.newInt8Array(name, value);
+        case Int16Array.name:
+            return polars_internal_1.default.JsSeries.newInt16Array(name, value);
+        case Int32Array.name:
+            return polars_internal_1.default.JsSeries.newInt32Array(name, value);
+        case BigInt64Array.name:
+            return polars_internal_1.default.JsSeries.newBigint64Array(name, value);
+        case Uint8Array.name:
+            return polars_internal_1.default.JsSeries.newUint8Array(name, value);
+        case Uint8ClampedArray.name:
+            return polars_internal_1.default.JsSeries.newUint8ClampedArray(name, value);
+        case Uint16Array.name:
+            return polars_internal_1.default.JsSeries.newUint16Array(name, value);
+        case Uint32Array.name:
+            return polars_internal_1.default.JsSeries.newUint32Array(name, value);
+        case BigUint64Array.name:
+            return polars_internal_1.default.JsSeries.newBiguint64Array(name, value);
+        case Float32Array.name:
+            return polars_internal_1.default.JsSeries.newFloat32Array(name, value);
+        case Float64Array.name:
+            return polars_internal_1.default.JsSeries.newFloat64Array(name, value);
+        default:
+            throw new Error(`unknown  typed array type: ${value.constructor.name}`);
+    }
+};
+/**
+ * Construct an internal `JsSeries` from an array
+ */
+function arrayToJsSeries(name = "", values = [], dtype) {
+    if ((0, types_1.isTypedArray)(values)) {
+        return fromTypedArray(name, values);
+    }
+    // Empty sequence defaults to Float64 type
+    if (!(values?.length || dtype)) {
+        dtype = datatypes_1.DataType.Float64;
+    }
+    const firstValue = firstNonNull(values);
+    if (Array.isArray(firstValue) || (0, types_1.isTypedArray)(firstValue)) {
+        const arrayDtype = dtype ?? datatypes_1.DataType.List((0, exports.jsTypeToPolarsType)(firstValue));
+        const ctor = (0, datatypes_1.polarsTypeToConstructor)(arrayDtype);
+        const s = ctor(name, values, arrayDtype);
+        if (dtype instanceof datatype_1.FixedSizeList) {
+            // TODO: build a FixedSizeList natively in Rust
+            return s.cast(dtype);
+        }
+        return s;
+    }
+    dtype = dtype ?? (0, exports.jsTypeToPolarsType)(firstValue);
+    switch (dtype?.variant) {
+        case "Struct":
+            return polars_internal_1.default.fromRows(values, null, 1).toStruct(name);
+        case "Decimal":
+            if (typeof firstValue !== "bigint") {
+                throw new Error("Decimal type can only be constructed from BigInt");
+            }
+            return polars_internal_1.default.JsSeries.newAnyValue(name, values, dtype);
+        case "Time":
+            return polars_internal_1.default.JsSeries.newAnyValue(name, values, dtype);
+    }
+    let series;
+    if (firstValue instanceof Date) {
+        series = polars_internal_1.default.JsSeries.newOptDate(name, values);
+    }
+    else {
+        const ctor = (0, datatypes_1.polarsTypeToConstructor)(dtype);
+        series = ctor(name, values);
+    }
+    if ([
+        "Datetime",
+        "Date",
+        "Time",
+        "Categorical",
+        "Int8",
+        "Int16",
+        "UInt8",
+        "UInt16",
+        "Float32",
+    ].includes(dtype.variant)) {
+        series = series.cast(dtype);
+    }
+    return series;
+}
+function arrayToJsDataFrame(data, options) {
+    const columns = options?.columns;
+    let orient = options?.orient;
+    const schema = options?.schema;
+    const inferSchemaLength = options?.inferSchemaLength;
+    let dataSeries;
+    if (!data.length) {
+        dataSeries = [];
+    }
+    else if (data[0]?._s) {
+        dataSeries = [];
+        for (const [idx, series] of data.entries()) {
+            if (!series.name) {
+                series.rename(`column_${idx}`, true);
+            }
+            dataSeries.push(series._s);
+        }
+    }
+    else if (data[0].constructor.name === "Object") {
+        const df = polars_internal_1.default.fromRows(data, schema, inferSchemaLength);
+        if (columns) {
+            df.columns = columns;
+        }
+        return df;
+    }
+    else if (Array.isArray(data[0])) {
+        if (!orient && columns) {
+            orient = columns.length === data.length ? "col" : "row";
+        }
+        if (orient === "row") {
+            const df = polars_internal_1.default.fromRows(data);
+            if (columns)
+                df.columns = columns;
+            return df;
+        }
+        dataSeries = data.map((s, idx) => (0, series_1.Series)(`column_${idx}`, s)._s);
+    }
+    else {
+        dataSeries = [(0, series_1.Series)("column_0", data)._s];
+    }
+    dataSeries = handleColumnsArg(dataSeries, columns);
+    return new polars_internal_1.default.JsDataFrame(dataSeries);
+}
+function handleColumnsArg(data, columns) {
+    if (!columns) {
+        return data;
+    }
+    if (!data) {
+        return columns.map((c) => series_1.Series.from(c, [])._s);
+    }
+    if (data.length === columns.length) {
+        for (const [idx, name] of columns.entries()) {
+            data[idx].rename(name);
+        }
+        return data;
+    }
+    throw new TypeError("Dimensions of columns arg must match data dimensions.");
+}

package/bin/internals/polars_internal.d.ts

@@ -0,0 +1,2 @@
+import pl from "../native-polars.js";
+export default pl;

package/bin/internals/polars_internal.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const native_polars_js_1 = __importDefault(require("../native-polars.js"));
+exports.default = native_polars_js_1.default;