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

package/bin/lazy/expr/string.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExprStringFunctions = void 0;
+const datatypes_1 = require("../../datatypes");
+const expr_1 = require("../expr");
+const functions_1 = require("../functions");
+const ExprStringFunctions = (_expr) => {
+    const wrap = (method, ...args) => {
+        return (0, expr_1._Expr)(_expr[method](...args));
+    };
+    const handleDecode = (encoding, strict) => {
+        switch (encoding) {
+            case "hex":
+                return wrap("strHexDecode", strict);
+            case "base64":
+                return wrap("strBase64Decode", strict);
+            default:
+                throw new RangeError("supported encodings are 'hex' and 'base64'");
+        }
+    };
+    return {
+        concat(delimiter, ignoreNulls = true) {
+            return wrap("strConcat", delimiter, ignoreNulls);
+        },
+        contains(pat, literal = false, strict = true) {
+            return wrap("strContains", (0, expr_1.exprToLitOrExpr)(pat)._expr, literal, strict);
+        },
+        decode(arg, strict = false) {
+            if (typeof arg === "string") {
+                return handleDecode(arg, strict);
+            }
+            return handleDecode(arg.encoding, arg.strict);
+        },
+        encode(encoding) {
+            switch (encoding) {
+                case "hex":
+                    return wrap("strHexEncode");
+                case "base64":
+                    return wrap("strBase64Encode");
+                default:
+                    throw new RangeError("supported encodings are 'hex' and 'base64'");
+            }
+        },
+        endsWith(suffix) {
+            return wrap("strEndsWith", (0, expr_1.exprToLitOrExpr)(suffix)._expr);
+        },
+        extract(pattern, groupIndex) {
+            return wrap("strExtract", (0, expr_1.exprToLitOrExpr)(pattern, true)._expr, groupIndex);
+        },
+        jsonDecode(dtype) {
+            if (!dtype)
+                throw new Error("`Expr.str.json_decode` needs an explicitly given `dtype` otherwise Polars is not able to determine the output type. If you want to eagerly infer datatype you can use `Series.str.json_decode`.");
+            return wrap("strJsonDecode", dtype);
+        },
+        jsonPathMatch(pat) {
+            return wrap("strJsonPathMatch", [pat]);
+        },
+        lengths() {
+            return wrap("strLengths");
+        },
+        lstrip() {
+            return wrap("strLstrip");
+        },
+        replace(pat, val, literal = false, n = 1) {
+            return wrap("strReplace", (0, expr_1.exprToLitOrExpr)(pat)._expr, (0, expr_1.exprToLitOrExpr)(val)._expr, literal, n);
+        },
+        replaceAll(pat, val, literal = false) {
+            return wrap("strReplaceAll", (0, expr_1.exprToLitOrExpr)(pat)._expr, (0, expr_1.exprToLitOrExpr)(val)._expr, literal);
+        },
+        rstrip() {
+            return wrap("strRstrip");
+        },
+        padStart(length, fillChar) {
+            return wrap("strPadStart", (0, functions_1.lit)(length)._expr, fillChar);
+        },
+        zFill(length) {
+            if (!expr_1.Expr.isExpr(length)) {
+                length = (0, functions_1.lit)(length)._expr;
+            }
+            return wrap("zfill", length);
+        },
+        padEnd(length, fillChar) {
+            return wrap("strPadEnd", (0, functions_1.lit)(length)._expr, fillChar);
+        },
+        slice(start, length) {
+            if (!expr_1.Expr.isExpr(start)) {
+                start = (0, functions_1.lit)(start)._expr;
+            }
+            if (!expr_1.Expr.isExpr(length)) {
+                length = (0, functions_1.lit)(length)._expr;
+            }
+            return wrap("strSlice", start, length);
+        },
+        split(by, options) {
+            const inclusive = typeof options === "boolean" ? options : options?.inclusive;
+            return wrap("strSplit", (0, expr_1.exprToLitOrExpr)(by)._expr, inclusive);
+        },
+        startsWith(prefix) {
+            return wrap("strStartsWith", (0, expr_1.exprToLitOrExpr)(prefix)._expr);
+        },
+        strip() {
+            return wrap("strStrip");
+        },
+        stripChars(pattern) {
+            return wrap("strStripChars", (0, expr_1.exprToLitOrExpr)(pattern)._expr, true, true);
+        },
+        stripCharsEnd(pattern) {
+            return wrap("strStripChars", (0, expr_1.exprToLitOrExpr)(pattern)._expr, false, true);
+        },
+        stripCharsStart(pattern) {
+            return wrap("strStripChars", (0, expr_1.exprToLitOrExpr)(pattern)._expr, true, false);
+        },
+        strptime(dtype, format) {
+            const dt = dtype instanceof datatypes_1.DataType ? dtype : dtype();
+            if (dt.equals(datatypes_1.DataType.Date)) {
+                return wrap("strToDate", format, false, false, false);
+            }
+            if (dt.equals(datatypes_1.DataType.Datetime("ms"))) {
+                return wrap("strToDatetime", format, undefined, undefined, false, false, false, undefined);
+            }
+            throw new Error(`only "DataType.Date" and "DataType.Datetime" are supported`);
+        },
+        toLowerCase() {
+            return wrap("strToLowercase");
+        },
+        toUpperCase() {
+            return wrap("strToUppercase");
+        },
+    };
+};
+exports.ExprStringFunctions = ExprStringFunctions;

package/bin/lazy/expr/struct.d.ts

@@ -0,0 +1,126 @@
+import { type Expr } from "../expr";
+/**
+ * Struct functions for Lazy datatframes
+ */
+export interface ExprStruct {
+    /**
+     * Access a field by name
+     * @param name - name of the field
+     * @example
+     * pl.DataFrame({
+           objs: [
+             { a: 1, b: 2.0, c: "abc" },
+             { a: 10, b: 20.0, c: "def" },
+           ],
+         }).select(
+            col("objs").struct.field("b"),
+            col("objs").struct.field("c").as("last")
+          );
+      >>shape: (2, 2)
+      ┌──────┬──────┐
+      │ b    ┆ last │
+      │ ---  ┆ ---  │
+      │ f64  ┆ str  │
+      ╞══════╪══════╡
+      │ 2.0  ┆ abc  │
+      │ 20.0 ┆ def  │
+      └──────┴──────┘
+     */
+    field(name: string): Expr;
+    /**
+     * Access a field by index (zero based index)
+     * @param index - index of the field (starts at 0)
+     *
+     * @example
+     * pl.DataFrame({
+           objs: [
+             { a: 1, b: 2.0, c: "abc" },
+             { a: 10, b: 20.0, c: "def" },
+           ],
+         }).select(
+            col("objs").struct.nth(1),
+            col("objs").struct.nth(2).as("last"),
+          );
+      >>shape: (2, 2)
+      ┌──────┬──────┐
+      │ b    ┆ last │
+      │ ---  ┆ ---  │
+      │ f64  ┆ str  │
+      ╞══════╪══════╡
+      │ 2.0  ┆ abc  │
+      │ 20.0 ┆ def  │
+      └──────┴──────┘
+     */
+    nth(index: number): Expr;
+    /**
+     * Rename the fields of a struct
+     * @param names - new names of the fields
+     *
+     * @example
+     * pl.DataFrame({
+           objs: [
+             { a: 1, b: 2.0, c: "abc" },
+             { a: 10, b: 20.0, c: "def" },
+           ]}).select(col("objs").struct.renameFields(["a", "b", "c"]));
+      >>shape: (2, 1)
+      ┌───────────────────┐
+      │ objs              │
+      │ ---               │
+      │ struct[3]         │
+      ╞═══════════════════╡
+      │ {1.0,2.0,"abc"}   │
+      │ {10.0,20.0,"def"} │
+      └───────────────────┘
+     */
+    renameFields(names: string[]): Expr;
+    /**
+     * Add/replace fields in a struct
+     * @param fields - array of expressions for new fields
+     *
+     * @example
+     * pl.DataFrame({
+           objs: [
+             { a: 1, b: 2.0, c: "abc" },
+             { a: 10, b: 20.0, c: "def" },
+           ],
+           more: ["text1", "text2"],
+           final: [100, null],
+         }).select(
+               col("objs").struct.withFields([
+                 pl.lit(null).alias("d"),
+                 pl.lit("text").alias("e"),
+               ]),
+               col("objs")
+                 .struct.withFields([col("more"), col("final")])
+                 .alias("new"),
+             );
+      shape: (2, 2)
+      ┌───────────────────────────────┬────────────────────────────────┐
+      │ objs                          ┆ new                            │
+      │ ---                           ┆ ---                            │
+      │ struct[5]                     ┆ struct[5]                      │
+      ╞═══════════════════════════════╪════════════════════════════════╡
+      │ {1.0,2.0,"abc",null,"text"}   ┆ {1.0,2.0,"abc","text1",100.0}  │
+      │ {10.0,20.0,"def",null,"text"} ┆ {10.0,20.0,"def","text2",null} │
+      └───────────────────────────────┴────────────────────────────────┘
+     */
+    withFields(fields: Expr[]): Expr;
+    /**
+     * Convert this struct to a string column with json values.
+     *
+     * @example
+     * pl.DataFrame( {"a": [{"a": [1, 2], "b": [45]}, {"a": [9, 1, 3], "b": null}]}
+                   ).withColumn(pl.col("a").struct.jsonEncode().alias("encoded"))
+      shape: (2, 2)
+      ┌──────────────────┬────────────────────────┐
+      │ a                ┆ encoded                │
+      │ ---              ┆ ---                    │
+      │ struct[2]        ┆ str                    │
+      ╞══════════════════╪════════════════════════╡
+      │ {[1, 2],[45]}    ┆ {"a":[1,2],"b":[45]}   │
+      │ {[9, 1, 3],null} ┆ {"a":[9,1,3],"b":null} │
+      └──────────────────┴────────────────────────┘
+     */
+    jsonEncode(): Expr;
+}
+export declare const ExprStructFunctions: (_expr: any) => ExprStruct;

package/bin/lazy/expr/struct.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExprStructFunctions = void 0;
+const utils_1 = require("../../utils");
+const expr_1 = require("../expr");
+const ExprStructFunctions = (_expr) => {
+    return {
+        field(name) {
+            return (0, expr_1._Expr)(_expr.structFieldByName(name));
+        },
+        nth(index) {
+            return (0, expr_1._Expr)(_expr.structFieldByIndex(index));
+        },
+        renameFields(names) {
+            return (0, expr_1._Expr)(_expr.structRenameFields(names));
+        },
+        withFields(fields) {
+            fields = (0, utils_1.selectionToExprList)(fields, false);
+            return (0, expr_1._Expr)(_expr.structWithFields(fields));
+        },
+        jsonEncode() {
+            return (0, expr_1._Expr)(_expr.structJsonEncode());
+        },
+    };
+};
+exports.ExprStructFunctions = ExprStructFunctions;