df-script 1.4.0

package/dist/columnExpressions/mixins/WindowExpr.js

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WindowExpr = void 0;
+const ExprBase_1 = require("../ExprBase");
+const utils_1 = require("../../utils");
+const WindowExpr = (Base) => {
+    return class extends Base {
+        partitionBy = this.partitionBy || null;
+        _rolling(windowSize, aggFn) {
+            const newInst = (0, ExprBase_1.derive)(this);
+            newInst.partitionOpsIndex = this.ops.length;
+            newInst.groupingOpsIndex = this.ops.length;
+            newInst.evaluateWindow = function (groupPreValues, _partitionIndices, currentIndex) {
+                const start = Math.max(0, currentIndex - windowSize + 1);
+                const end = currentIndex + 1;
+                const windowVals = groupPreValues.slice(start, end);
+                return aggFn(windowVals);
+            };
+            return newInst;
+        }
+        get isWindow() {
+            return this.partitionBy !== null || this.evaluateWindow !== undefined || this.aggFn !== null;
+        }
+        cum_count(reverse = false) {
+            const newInst = (0, ExprBase_1.derive)(this);
+            newInst.partitionOpsIndex = this.ops.length;
+            newInst.groupingOpsIndex = this.ops.length;
+            newInst.evaluateWindow = function (groupPreValues, _partitionIndices, currentIndex) {
+                let count = 0;
+                const start = reverse ? currentIndex : 0;
+                const end = reverse ? groupPreValues.length - 1 : currentIndex;
+                for (let i = start; i <= end; i++) {
+                    const val = groupPreValues[i];
+                    if (val != null)
+                        count++;
+                }
+                return count;
+            };
+            return newInst;
+        }
+        cum_max(reverse = false) {
+            const newInst = (0, ExprBase_1.derive)(this);
+            newInst.partitionOpsIndex = this.ops.length;
+            newInst.groupingOpsIndex = this.ops.length;
+            newInst.evaluateWindow = function (groupPreValues, _partitionIndices, currentIndex) {
+                let maxVal = null;
+                const start = reverse ? currentIndex : 0;
+                const end = reverse ? groupPreValues.length - 1 : currentIndex;
+                for (let i = start; i <= end; i++) {
+                    const val = groupPreValues[i];
+                    if (val != null) {
+                        if (maxVal === null || val > maxVal) {
+                            maxVal = val;
+                        }
+                    }
+                }
+                return maxVal;
+            };
+            return newInst;
+        }
+        cum_min(reverse = false) {
+            const newInst = (0, ExprBase_1.derive)(this);
+            newInst.partitionOpsIndex = this.ops.length;
+            newInst.groupingOpsIndex = this.ops.length;
+            newInst.evaluateWindow = function (groupPreValues, _partitionIndices, currentIndex) {
+                let minVal = null;
+                const start = reverse ? currentIndex : 0;
+                const end = reverse ? groupPreValues.length - 1 : currentIndex;
+                for (let i = start; i <= end; i++) {
+                    const val = groupPreValues[i];
+                    if (val != null) {
+                        if (minVal === null || val < minVal) {
+                            minVal = val;
+                        }
+                    }
+                }
+                return minVal;
+            };
+            return newInst;
+        }
+        cum_prod(reverse = false) {
+            const newInst = (0, ExprBase_1.derive)(this);
+            newInst.partitionOpsIndex = this.ops.length;
+            newInst.groupingOpsIndex = this.ops.length;
+            newInst.evaluateWindow = function (groupPreValues, _partitionIndices, currentIndex) {
+                let prod = 1;
+                let hasValid = false;
+                const start = reverse ? currentIndex : 0;
+                const end = reverse ? groupPreValues.length - 1 : currentIndex;
+                for (let i = start; i <= end; i++) {
+                    const val = groupPreValues[i];
+                    if (val != null) {
+                        prod *= val;
+                        hasValid = true;
+                    }
+                }
+                return hasValid ? prod : null;
+            };
+            return newInst;
+        }
+        cum_sum(reverse = false) {
+            const newInst = (0, ExprBase_1.derive)(this);
+            newInst.partitionOpsIndex = this.ops.length;
+            newInst.groupingOpsIndex = this.ops.length;
+            newInst.evaluateWindow = function (groupPreValues, _partitionIndices, currentIndex) {
+                let sum = 0;
+                const start = reverse ? currentIndex : 0;
+                const end = reverse ? groupPreValues.length - 1 : currentIndex;
+                for (let i = start; i <= end; i++) {
+                    const val = groupPreValues[i];
+                    if (val != null)
+                        sum += val;
+                }
+                return sum;
+            };
+            return newInst;
+        }
+        dense_rank() {
+            const newInst = (0, ExprBase_1.derive)(this);
+            newInst.partitionOpsIndex = this.ops.length;
+            newInst.groupingOpsIndex = this.ops.length;
+            newInst.evaluateWindow = function (groupPreValues, _partitionIndices, currentIndex) {
+                const sortedUnique = Array.from(new Set(groupPreValues)).sort((a, b) => a - b);
+                const valueToRank = new Map();
+                for (let idx = 0; idx < sortedUnique.length; idx++) {
+                    valueToRank.set(sortedUnique[idx], idx + 1);
+                }
+                const currentVal = groupPreValues[currentIndex];
+                return valueToRank.get(currentVal) ?? null;
+            };
+            return newInst;
+        }
+        lag(offset = 1, defaultVal = null) {
+            const newInst = (0, ExprBase_1.derive)(this);
+            newInst.partitionOpsIndex = this.ops.length;
+            newInst.groupingOpsIndex = this.ops.length;
+            newInst.evaluateWindow = function (groupPreValues, _partitionIndices, currentIndex) {
+                let val = defaultVal;
+                if (currentIndex - offset >= 0) {
+                    val = groupPreValues[currentIndex - offset];
+                }
+                return val;
+            };
+            return newInst;
+        }
+        lead(offset = 1, defaultVal = null) {
+            const newInst = (0, ExprBase_1.derive)(this);
+            newInst.partitionOpsIndex = this.ops.length;
+            newInst.groupingOpsIndex = this.ops.length;
+            newInst.evaluateWindow = function (groupPreValues, _partitionIndices, currentIndex) {
+                let val = defaultVal;
+                if (currentIndex + offset < groupPreValues.length) {
+                    val = groupPreValues[currentIndex + offset];
+                }
+                return val;
+            };
+            return newInst;
+        }
+        over(columns) {
+            const newInst = (0, ExprBase_1.derive)(this);
+            const cols = Array.isArray(columns) ? columns : [columns];
+            newInst.partitionBy = cols;
+            return newInst;
+        }
+        rank() {
+            const newInst = (0, ExprBase_1.derive)(this);
+            newInst.partitionOpsIndex = this.ops.length;
+            newInst.groupingOpsIndex = this.ops.length;
+            newInst.evaluateWindow = function (groupPreValues, _partitionIndices, currentIndex) {
+                const sorted = [...groupPreValues].sort((a, b) => a - b);
+                const valueToRank = new Map();
+                for (let i = 0; i < sorted.length; i++) {
+                    const v = sorted[i];
+                    if (!valueToRank.has(v)) {
+                        valueToRank.set(v, i + 1);
+                    }
+                }
+                const currentVal = groupPreValues[currentIndex];
+                return valueToRank.get(currentVal) ?? null;
+            };
+            return newInst;
+        }
+        rolling_max(windowSize) {
+            return this._rolling(windowSize, v => (0, utils_1.getListStats)(v).max);
+        }
+        rolling_mean(windowSize) {
+            return this._rolling(windowSize, v => (0, utils_1.getListStats)(v).mean);
+        }
+        rolling_median(windowSize) {
+            return this._rolling(windowSize, v => {
+                if (!(0, utils_1.isArrayOfType)(v, "number", { allowNulls: true }))
+                    return null;
+                const len = v.length;
+                const nums = [];
+                for (let i = 0; i < len; i++) {
+                    const val = v[i];
+                    if (val != null) {
+                        nums.push(val);
+                    }
+                }
+                const numsLen = nums.length;
+                if (numsLen === 0)
+                    return null;
+                nums.sort((a, b) => a - b);
+                const mid = Math.floor(numsLen / 2);
+                return numsLen % 2 !== 0
+                    ? nums[mid]
+                    : (nums[mid - 1] + nums[mid]) / 2;
+            });
+        }
+        rolling_min(windowSize) {
+            return this._rolling(windowSize, v => (0, utils_1.getListStats)(v).min);
+        }
+        rolling_quantile(quantile, windowSize) {
+            return this._rolling(windowSize, v => {
+                const f = [];
+                for (let i = 0; i < v.length; i++) {
+                    if (v[i] != null)
+                        f.push(v[i]);
+                }
+                const n = f.length;
+                if (n === 0)
+                    return null;
+                f.sort((a, b) => a - b);
+                const idx = quantile * (n - 1);
+                const low = Math.floor(idx);
+                const high = Math.ceil(idx);
+                if (low === high)
+                    return f[low];
+                return f[low] + (idx - low) * (f[high] - f[low]);
+            });
+        }
+        rolling_rank(windowSize) {
+            const newInst = (0, ExprBase_1.derive)(this);
+            newInst.partitionOpsIndex = this.ops.length;
+            newInst.groupingOpsIndex = this.ops.length;
+            newInst.evaluateWindow = function (groupPreValues, _partitionIndices, currentIndex) {
+                const start = Math.max(0, currentIndex - windowSize + 1);
+                const end = currentIndex + 1;
+                const vals = groupPreValues.slice(start, end);
+                const currentVal = groupPreValues[currentIndex];
+                if (currentVal == null)
+                    return null;
+                const nonNullVals = [];
+                for (let j = 0; j < vals.length; j++) {
+                    if (vals[j] != null)
+                        nonNullVals.push(vals[j]);
+                }
+                if (nonNullVals.length === 0)
+                    return null;
+                const sorted = [...nonNullVals].sort((a, b) => a - b);
+                const valueToRank = new Map();
+                for (let i = 0; i < sorted.length; i++) {
+                    const v = sorted[i];
+                    if (!valueToRank.has(v)) {
+                        valueToRank.set(v, i + 1);
+                    }
+                }
+                return valueToRank.get(currentVal) ?? null;
+            };
+            return newInst;
+        }
+        rolling_std(windowSize) {
+            return this._rolling(windowSize, v => (0, utils_1.getListStats)(v).std);
+        }
+        rolling_sum(windowSize) {
+            return this._rolling(windowSize, v => (0, utils_1.getListStats)(v).sum);
+        }
+        row_number() {
+            const newInst = (0, ExprBase_1.derive)(this);
+            newInst.partitionOpsIndex = this.ops.length;
+            newInst.groupingOpsIndex = this.ops.length;
+            newInst.evaluateWindow = function (_groupPreValues, _partitionIndices, currentIndex) {
+                return currentIndex + 1;
+            };
+            newInst.outputName = "row_number";
+            return newInst;
+        }
+    };
+};
+exports.WindowExpr = WindowExpr;

package/dist/columnExpressions/types.d.ts

@@ -0,0 +1,7 @@
+import type { IExpr } from "../types";
+export type ExprConstructor = new (...args: any[]) => IExpr;
+export interface RandomOptions {
+    min?: number;
+    max?: number;
+    integer?: boolean;
+}

package/dist/columnExpressions/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/dataframe/constants.d.ts

@@ -0,0 +1 @@
+export declare const KEY_SEPARATOR = "\0";

package/dist/dataframe/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KEY_SEPARATOR = void 0;
+exports.KEY_SEPARATOR = "\x00";

package/dist/dataframe/dataframe.d.ts

@@ -0,0 +1,42 @@
+import { GroupedData } from "./grouped/grouped";
+import type { IExpr, ColumnDict, DataFrameColumns, ConcatOptions, ConcatItem, HorizontalConcatOptions, RowRecord } from "../types";
+import type { LimitOptions, SortOptions, PivotOptions, JoinOptions, UnpivotOptions } from "./types";
+import { DataType } from "../datatypes";
+export declare class DataFrame<T extends RowRecord = any> {
+    _columns: DataFrameColumns<T>;
+    private _height;
+    private _schema;
+    constructor(data: T[] | ColumnDict, schema?: Record<string, DataType>, height?: number);
+    private inferSchema;
+    private applySchema;
+    getSchema(): Record<string, DataType>;
+    to_dicts(): T[];
+    to_dict(): DataFrameColumns<T>;
+    get columns(): string[];
+    concat<U extends RowRecord = any>(items: ConcatItem | ConcatItem[], options?: ConcatOptions): DataFrame<U>;
+    drop<K extends keyof T>(...args: (K | K[])[]): DataFrame<Omit<T, K>>;
+    get dtypes(): DataType[];
+    filter(...exprs: (IExpr | ((row: T) => any))[]): DataFrame<T>;
+    groupby<K extends keyof T>(keys: K | K[]): GroupedData<T, K>;
+    head(n?: number): DataFrame<T>;
+    get height(): number;
+    hstack<U extends RowRecord = any>(other: ConcatItem | ConcatItem[], options?: HorizontalConcatOptions): DataFrame<U>;
+    join<U extends RowRecord = any, R extends RowRecord = any>(config: JoinOptions<T, U>): DataFrame<R>;
+    limit(n: number, options?: LimitOptions): DataFrame<T>;
+    pivot<U extends RowRecord = any>(config: PivotOptions<T>): DataFrame<U>;
+    rename(mapping?: Partial<Record<keyof T, string>>): DataFrame<any>;
+    reverse(): DataFrame<T>;
+    get schema(): Record<string, DataType>;
+    select<U extends RowRecord = any>(...args: (string | IExpr | Record<string, any> | (string | IExpr | Record<string, any>)[])[]): DataFrame<U>;
+    get shape(): [number, number];
+    slice(start: number, end?: number): DataFrame<T>;
+    sort(config?: SortOptions<T>): DataFrame<T>;
+    tail(n?: number): DataFrame<T>;
+    to_list<K extends keyof T>(nameOrExpr: K | IExpr): any[];
+    unique<K extends keyof T>(columns?: K | K[]): DataFrame<T>;
+    unpivot<U extends RowRecord = any>(config: UnpivotOptions<T>): DataFrame<U>;
+    vstack<U extends RowRecord = any>(other: ConcatItem | ConcatItem[]): DataFrame<U>;
+    get width(): number;
+    private _normalizeArgs;
+    with_columns(...args: (string | IExpr | Record<string, any> | (string | IExpr | Record<string, any>)[])[]): DataFrame<any>;
+}