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

package/bin/lazy/groupby.d.ts

@@ -0,0 +1,29 @@
+import { type LazyDataFrame } from "./dataframe";
+import type { Expr } from "./expr";
+/** @ignore */
+export declare const _LazyGroupBy: (_lgb: any) => LazyGroupBy;
+/**
+ * LazyGroupBy
+ * @category lazy
+ */
+export interface LazyGroupBy {
+    /**
+     * Aggregate the groupby.
+     */
+    agg(...aggs: Expr[]): LazyDataFrame;
+    /**
+     * Return the first n rows of the groupby.
+     * @param n number of rows to return
+     */
+    head(n?: number): LazyDataFrame;
+    /**
+     * Return the number of rows in each group.
+     * @param name Assign a name to the resulting column; if unset, defaults to "len".
+     */
+    len(name?: string): LazyDataFrame;
+    /**
+     * Return the last n rows of the groupby.
+     * @param n number of rows to return
+     */
+    tail(n?: number): LazyDataFrame;
+}

package/bin/lazy/groupby.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._LazyGroupBy = void 0;
+const polars_internal_1 = __importDefault(require("../internals/polars_internal"));
+const utils_1 = require("../utils");
+const dataframe_1 = require("./dataframe");
+/** @ignore */
+const _LazyGroupBy = (_lgb) => {
+    return {
+        agg(...aggs) {
+            aggs = (0, utils_1.selectionToExprList)(aggs, false);
+            const ret = _lgb.agg(aggs.flat());
+            return (0, dataframe_1._LazyDataFrame)(ret);
+        },
+        head(n = 5) {
+            return (0, dataframe_1._LazyDataFrame)(_lgb.head(n));
+        },
+        len(name) {
+            const expr = name ? polars_internal_1.default.len().alias(name) : polars_internal_1.default.len();
+            return (0, dataframe_1._LazyDataFrame)(_lgb.agg([expr]));
+        },
+        tail(n = 5) {
+            return (0, dataframe_1._LazyDataFrame)(_lgb.tail(n));
+        },
+    };
+};
+exports._LazyGroupBy = _LazyGroupBy;

package/bin/lazy/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./expr";
+export * from "./functions";
+export * from "./groupby";
+export * from "./whenthen";

package/bin/lazy/index.js

@@ -0,0 +1,20 @@
+"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 __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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./expr"), exports);
+__exportStar(require("./functions"), exports);
+__exportStar(require("./groupby"), exports);
+__exportStar(require("./whenthen"), exports);

package/bin/lazy/whenthen.d.ts

@@ -0,0 +1,67 @@
+import { Expr } from "./expr";
+export interface When {
+    /** Values to return in case of the predicate being `true`.*/
+    then(expr: Expr): Then;
+}
+export interface Then {
+    /** Start another when, then, otherwise layer. */
+    when(predicate: Expr): ChainedWhen;
+    /** Values to return in case of the predicate being `false`. */
+    otherwise(expr: Expr): Expr;
+}
+export interface ChainedWhen {
+    /** Values to return in case of the predicate being `true`. */
+    then(expr: Expr): ChainedThen;
+}
+export interface ChainedThen {
+    /** Start another when, then, otherwise layer. */
+    when(predicate: Expr): ChainedWhen;
+    /** Values to return in case of the predicate being `true`. */
+    then(expr: Expr): ChainedThen;
+    /** Values to return in case of the predicate being `false`. */
+    otherwise(expr: Expr): Expr;
+}
+/**
+ * Start a when, then, otherwise expression.
+ *
+ * @example
+ * ```
+ * // Below we add a column with the value 1, where column "foo" > 2 and the value -1 where it isn't.
+ * > df = pl.DataFrame({"foo": [1, 3, 4], "bar": [3, 4, 0]})
+ * > df.withColumn(pl.when(pl.col("foo").gt(2)).then(pl.lit(1)).otherwise(pl.lit(-1)))
+ * shape: (3, 3)
+ * ┌─────┬─────┬─────────┐
+ * │ foo ┆ bar ┆ literal │
+ * │ --- ┆ --- ┆ ---     │
+ * │ i64 ┆ i64 ┆ i32     │
+ * ╞═════╪═════╪═════════╡
+ * │ 1   ┆ 3   ┆ -1      │
+ * ├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌┤
+ * │ 3   ┆ 4   ┆ 1       │
+ * ├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌┤
+ * │ 4   ┆ 0   ┆ 1       │
+ * └─────┴─────┴─────────┘
+ *
+ * // Or with multiple `when, thens` chained:
+ * > df.with_column(
+ * ...     pl.when(pl.col("foo").gt(2))
+ * ...     .then(1)
+ * ...     .when(pl.col("bar").gt(2))
+ * ...     .then(4)
+ * ...     .otherwise(-1)
+ * ... )
+ * shape: (3, 3)
+ * ┌─────┬─────┬─────────┐
+ * │ foo ┆ bar ┆ literal │
+ * │ --- ┆ --- ┆ ---     │
+ * │ i64 ┆ i64 ┆ i32     │
+ * ╞═════╪═════╪═════════╡
+ * │ 1   ┆ 3   ┆ 4       │
+ * ├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌┤
+ * │ 3   ┆ 4   ┆ 1       │
+ * ├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌┤
+ * │ 4   ┆ 0   ┆ 1       │
+ * └─────┴─────┴─────────┘
+ * ```
+ */
+export declare function when(expr: Expr): When;

package/bin/lazy/whenthen.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.when = when;
+const polars_internal_1 = __importDefault(require("../internals/polars_internal"));
+const expr_1 = require("./expr");
+function ChainedWhen(_chainedwhen) {
+    return {
+        then: ({ _expr }) => ChainedThen(_chainedwhen.then(_expr)),
+    };
+}
+function ChainedThen(_chainedthen) {
+    return {
+        when: ({ _expr }) => ChainedWhen(_chainedthen.when(_expr)),
+        then: ({ _expr }) => ChainedThen(_chainedthen.then(_expr)),
+        otherwise: ({ _expr }) => expr_1.Expr(_chainedthen.otherwise(_expr)),
+    };
+}
+function Then(_then) {
+    return {
+        when: ({ _expr }) => ChainedWhen(_then.when(_expr)),
+        otherwise: ({ _expr }) => expr_1.Expr(_then.otherwise(_expr)),
+    };
+}
+/**
+ * Utility function.
+ * @see {@link when}
+ */
+function When(_when) {
+    return {
+        then: ({ _expr }) => Then(_when.then(_expr)),
+    };
+}
+/**
+ * Start a when, then, otherwise expression.
+ *
+ * @example
+ * ```
+ * // Below we add a column with the value 1, where column "foo" > 2 and the value -1 where it isn't.
+ * > df = pl.DataFrame({"foo": [1, 3, 4], "bar": [3, 4, 0]})
+ * > df.withColumn(pl.when(pl.col("foo").gt(2)).then(pl.lit(1)).otherwise(pl.lit(-1)))
+ * shape: (3, 3)
+ * ┌─────┬─────┬─────────┐
+ * │ foo ┆ bar ┆ literal │
+ * │ --- ┆ --- ┆ ---     │
+ * │ i64 ┆ i64 ┆ i32     │
+ * ╞═════╪═════╪═════════╡
+ * │ 1   ┆ 3   ┆ -1      │
+ * ├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌┤
+ * │ 3   ┆ 4   ┆ 1       │
+ * ├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌┤
+ * │ 4   ┆ 0   ┆ 1       │
+ * └─────┴─────┴─────────┘
+ *
+ * // Or with multiple `when, thens` chained:
+ * > df.with_column(
+ * ...     pl.when(pl.col("foo").gt(2))
+ * ...     .then(1)
+ * ...     .when(pl.col("bar").gt(2))
+ * ...     .then(4)
+ * ...     .otherwise(-1)
+ * ... )
+ * shape: (3, 3)
+ * ┌─────┬─────┬─────────┐
+ * │ foo ┆ bar ┆ literal │
+ * │ --- ┆ --- ┆ ---     │
+ * │ i64 ┆ i64 ┆ i32     │
+ * ╞═════╪═════╪═════════╡
+ * │ 1   ┆ 3   ┆ 4       │
+ * ├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌┤
+ * │ 3   ┆ 4   ┆ 1       │
+ * ├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌┤
+ * │ 4   ┆ 0   ┆ 1       │
+ * └─────┴─────┴─────────┘
+ * ```
+ */
+function when(expr) {
+    return When(polars_internal_1.default.when(expr._expr));
+}

package/bin/native-polars.d.ts

@@ -0,0 +1,2 @@
+export = nativeBinding;
+declare let nativeBinding: null;

package/bin/native-polars.js

@@ -0,0 +1,267 @@
+"use strict";
+const { existsSync, readFileSync } = require('fs');
+const { join } = require('path');
+const { platform, arch } = process;
+let nativeBinding = null;
+let localFileExisted = false;
+let loadError = null;
+function isMusl() {
+    // For Node 10
+    if (!process.report || typeof process.report.getReport !== 'function') {
+        try {
+            const lddPath = require('child_process').execSync('which ldd').toString().trim();
+            return readFileSync(lddPath, 'utf8').includes('musl');
+        }
+        catch (e) {
+            return true;
+        }
+    }
+    else {
+        const { glibcVersionRuntime } = process.report.getReport().header;
+        return !glibcVersionRuntime;
+    }
+}
+switch (platform) {
+    case 'android':
+        switch (arch) {
+            case 'arm64':
+                localFileExisted = existsSync(join(__dirname, 'nodejs-polars.android-arm64.node'));
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./nodejs-polars.android-arm64.node');
+                    }
+                    else {
+                        nativeBinding = require('nodejs-polars-android-arm64');
+                    }
+                }
+                catch (e) {
+                    loadError = e;
+                }
+                break;
+            case 'arm':
+                localFileExisted = existsSync(join(__dirname, 'nodejs-polars.android-arm-eabi.node'));
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./nodejs-polars.android-arm-eabi.node');
+                    }
+                    else {
+                        nativeBinding = require('nodejs-polars-android-arm-eabi');
+                    }
+                }
+                catch (e) {
+                    loadError = e;
+                }
+                break;
+            default:
+                throw new Error(`Unsupported architecture on Android ${arch}`);
+        }
+        break;
+    case 'win32':
+        switch (arch) {
+            case 'x64':
+                localFileExisted = existsSync(join(__dirname, 'nodejs-polars.win32-x64-msvc.node'));
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./nodejs-polars.win32-x64-msvc.node');
+                    }
+                    else {
+                        nativeBinding = require('nodejs-polars-win32-x64-msvc');
+                    }
+                }
+                catch (e) {
+                    loadError = e;
+                }
+                break;
+            case 'ia32':
+                localFileExisted = existsSync(join(__dirname, 'nodejs-polars.win32-ia32-msvc.node'));
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./nodejs-polars.win32-ia32-msvc.node');
+                    }
+                    else {
+                        nativeBinding = require('nodejs-polars-win32-ia32-msvc');
+                    }
+                }
+                catch (e) {
+                    loadError = e;
+                }
+                break;
+            case 'arm64':
+                localFileExisted = existsSync(join(__dirname, 'nodejs-polars.win32-arm64-msvc.node'));
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./nodejs-polars.win32-arm64-msvc.node');
+                    }
+                    else {
+                        nativeBinding = require('nodejs-polars-win32-arm64-msvc');
+                    }
+                }
+                catch (e) {
+                    loadError = e;
+                }
+                break;
+            default:
+                throw new Error(`Unsupported architecture on Windows: ${arch}`);
+        }
+        break;
+    case 'darwin':
+        switch (arch) {
+            case 'x64':
+                localFileExisted = existsSync(join(__dirname, 'nodejs-polars.darwin-x64.node'));
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./nodejs-polars.darwin-x64.node');
+                    }
+                    else {
+                        nativeBinding = require('nodejs-polars-darwin-x64');
+                    }
+                }
+                catch (e) {
+                    loadError = e;
+                }
+                break;
+            case 'arm64':
+                localFileExisted = existsSync(join(__dirname, 'nodejs-polars.darwin-arm64.node'));
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./nodejs-polars.darwin-arm64.node');
+                    }
+                    else {
+                        nativeBinding = require('nodejs-polars-darwin-arm64');
+                    }
+                }
+                catch (e) {
+                    loadError = e;
+                }
+                break;
+            default:
+                throw new Error(`Unsupported architecture on macOS: ${arch}`);
+        }
+        break;
+    case 'freebsd':
+        if (arch !== 'x64') {
+            throw new Error(`Unsupported architecture on FreeBSD: ${arch}`);
+        }
+        localFileExisted = existsSync(join(__dirname, 'nodejs-polars.freebsd-x64.node'));
+        try {
+            if (localFileExisted) {
+                nativeBinding = require('./nodejs-polars.freebsd-x64.node');
+            }
+            else {
+                nativeBinding = require('nodejs-polars-freebsd-x64');
+            }
+        }
+        catch (e) {
+            loadError = e;
+        }
+        break;
+    case 'linux':
+        switch (arch) {
+            case 'x64':
+                if (isMusl()) {
+                    localFileExisted = existsSync(join(__dirname, 'nodejs-polars.linux-x64-musl.node'));
+                    try {
+                        if (localFileExisted) {
+                            nativeBinding = require('./nodejs-polars.linux-x64-musl.node');
+                        }
+                        else {
+                            nativeBinding = require('nodejs-polars-linux-x64-musl');
+                        }
+                    }
+                    catch (e) {
+                        loadError = e;
+                    }
+                }
+                else {
+                    localFileExisted = existsSync(join(__dirname, 'nodejs-polars.linux-x64-gnu.node'));
+                    try {
+                        if (localFileExisted) {
+                            nativeBinding = require('./nodejs-polars.linux-x64-gnu.node');
+                        }
+                        else {
+                            nativeBinding = require('nodejs-polars-linux-x64-gnu');
+                        }
+                    }
+                    catch (e) {
+                        loadError = e;
+                    }
+                }
+                break;
+            case 'arm64':
+                if (isMusl()) {
+                    localFileExisted = existsSync(join(__dirname, 'nodejs-polars.linux-arm64-musl.node'));
+                    try {
+                        if (localFileExisted) {
+                            nativeBinding = require('./nodejs-polars.linux-arm64-musl.node');
+                        }
+                        else {
+                            nativeBinding = require('nodejs-polars-linux-arm64-musl');
+                        }
+                    }
+                    catch (e) {
+                        loadError = e;
+                    }
+                }
+                else {
+                    localFileExisted = existsSync(join(__dirname, 'nodejs-polars.linux-arm64-gnu.node'));
+                    try {
+                        if (localFileExisted) {
+                            nativeBinding = require('./nodejs-polars.linux-arm64-gnu.node');
+                        }
+                        else {
+                            nativeBinding = require('nodejs-polars-linux-arm64-gnu');
+                        }
+                    }
+                    catch (e) {
+                        loadError = e;
+                    }
+                }
+                break;
+            case 'arm':
+                localFileExisted = existsSync(join(__dirname, 'nodejs-polars.linux-arm-gnueabihf.node'));
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./nodejs-polars.linux-arm-gnueabihf.node');
+                    }
+                    else {
+                        nativeBinding = require('nodejs-polars-linux-arm-gnueabihf');
+                    }
+                }
+                catch (e) {
+                    loadError = e;
+                }
+                break;
+            default:
+                throw new Error(`Unsupported architecture on Linux: ${arch}`);
+        }
+        break;
+    case 'openharmony':
+        switch (arch) {
+            case 'arm64':
+                localFileExisted = existsSync(join(__dirname, 'nodejs-polars.openharmony-arm64.node'));
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./nodejs-polars.openharmony-arm64.node');
+                    }
+                    else {
+                        nativeBinding = require('@ohos-ports/nodejs-polars-openharmony-arm64');
+                    }
+                }
+                catch (e) {
+                    loadError = e;
+                }
+                break;
+            default:
+                throw new Error(`Unsupported architecture on openharmony: ${arch}`);
+        }
+        break;
+    default:
+        throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`);
+}
+if (!nativeBinding) {
+    if (loadError) {
+        throw loadError;
+    }
+    throw new Error(`Failed to load native binding`);
+}
+module.exports = nativeBinding;

package/bin/series/datetime.d.ts

@@ -0,0 +1,8 @@
+import type { DateFunctions } from "../shared_traits";
+import { type Series } from ".";
+/**
+ * DateTime functions for Series
+ */
+export interface SeriesDateFunctions extends DateFunctions<Series> {
+}
+export declare const SeriesDateFunctions: (_s: any) => SeriesDateFunctions;

package/bin/series/datetime.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeriesDateFunctions = void 0;
+const functions_1 = require("../lazy/functions");
+const _1 = require(".");
+const SeriesDateFunctions = (_s) => {
+    const wrap = (method, ...args) => {
+        return (0, _1._Series)(_s[method](...args));
+    };
+    const wrapNullArgs = (method) => () => wrap(method);
+    return {
+        day: wrapNullArgs("day"),
+        hour: wrapNullArgs("hour"),
+        minute: wrapNullArgs("minute"),
+        month: wrapNullArgs("month"),
+        nanosecond: wrapNullArgs("nanosecond"),
+        ordinalDay: wrapNullArgs("ordinalDay"),
+        second: wrapNullArgs("second"),
+        strftime: (fmt) => wrap("strftime", fmt),
+        timestamp: wrapNullArgs("timestamp"),
+        week: wrapNullArgs("week"),
+        weekday: wrapNullArgs("weekday"),
+        year: wrapNullArgs("year"),
+        truncate: (every) => (0, _1._Series)(_s)
+            .toFrame()
+            .select((0, functions_1.col)(_s.name).dt.truncate(every))
+            .getColumn(_s.name),
+        round: (every) => (0, _1._Series)(_s)
+            .toFrame()
+            .select((0, functions_1.col)(_s.name).dt.round(every))
+            .getColumn(_s.name),
+    };
+};
+exports.SeriesDateFunctions = SeriesDateFunctions;