nodepyx 1.0.0

package/src/types/stubs/pandas.d.ts

@@ -0,0 +1,575 @@
+// =============================================================
+// nodepyx — Pre-built TypeScript stub for pandas
+// Version: 2.x
+// Source: https://pandas.pydata.org
+// =============================================================
+
+import type { PyProxy, DataFrameResult, SeriesResult } from 'nodepyx';
+
+declare module 'nodepyx/pandas' {
+
+  // ── Core constructors ──────────────────────────────────────────────────────
+
+  /**
+   * Two-dimensional, size-mutable, potentially heterogeneous tabular data.
+   */
+  export class DataFrame {
+    constructor(
+      data?: Record<string, unknown>[] | Record<string, unknown> | unknown[][],
+      index?: unknown[],
+      columns?: string[],
+      dtype?: string,
+    );
+
+    // Shape
+    readonly shape: Promise<[number, number]>;
+    readonly columns: Promise<string[]>;
+    readonly index: Promise<unknown[]>;
+    readonly dtypes: Promise<Record<string, string>>;
+    readonly size: Promise<number>;
+    readonly ndim: Promise<number>;
+    readonly empty: Promise<boolean>;
+
+    // Indexing
+    loc: PyProxy;
+    iloc: PyProxy;
+    at: PyProxy;
+    iat: PyProxy;
+
+    // Conversion
+    to_dict(orient?: 'records' | 'list' | 'dict' | 'split' | 'tight' | 'index'): Promise<unknown>;
+    to_json(path_or_buf?: string | null, orient?: string): Promise<string | null>;
+    to_csv(path_or_buf?: string | null, sep?: string, index?: boolean): Promise<string | null>;
+    to_parquet(path?: string, engine?: string): Promise<void>;
+    to_excel(excel_writer: string, sheet_name?: string): Promise<void>;
+    to_numpy(): Promise<Float64Array | unknown[][]>;
+    to_records(index?: boolean): Promise<unknown[]>;
+    to_string(): Promise<string>;
+    to_html(buf?: string | null): Promise<string | null>;
+    to_markdown(): Promise<string>;
+
+    // Selection
+    head(n?: number): Promise<DataFrameResult>;
+    tail(n?: number): Promise<DataFrameResult>;
+    sample(n?: number, frac?: number, replace?: boolean, random_state?: number): Promise<DataFrameResult>;
+    filter(items?: string[], like?: string, regex?: string, axis?: number | string): Promise<DataFrameResult>;
+    select_dtypes(include?: string | string[], exclude?: string | string[]): Promise<DataFrameResult>;
+
+    // Aggregation
+    groupby(by: string | string[], axis?: number | string, sort?: boolean, dropna?: boolean): PyProxy;
+    agg(func: string | string[] | Record<string, string | string[]>): Promise<DataFrameResult | SeriesResult>;
+    aggregate(func: string | string[] | Record<string, string | string[]>): Promise<DataFrameResult | SeriesResult>;
+    pivot_table(values?: string, index?: string | string[], columns?: string | string[], aggfunc?: string): Promise<DataFrameResult>;
+    pivot(index?: string, columns?: string, values?: string): Promise<DataFrameResult>;
+    melt(id_vars?: string | string[], value_vars?: string | string[], var_name?: string, value_name?: string): Promise<DataFrameResult>;
+    stack(level?: number | string): Promise<DataFrameResult | SeriesResult>;
+    unstack(level?: number | string): Promise<DataFrameResult | SeriesResult>;
+    crosstab(): Promise<DataFrameResult>;
+    resample(rule: string, axis?: number): PyProxy;
+
+    // Transformation
+    apply(func: PyProxy | ((...args: unknown[]) => unknown), axis?: number | string, raw?: boolean): Promise<DataFrameResult | SeriesResult>;
+    applymap(func: PyProxy | ((...args: unknown[]) => unknown)): Promise<DataFrameResult>;
+    map(func: PyProxy | ((...args: unknown[]) => unknown)): Promise<DataFrameResult>;
+    transform(func: string | ((...args: unknown[]) => unknown), axis?: number): Promise<DataFrameResult>;
+    pipe(func: PyProxy | ((...args: unknown[]) => unknown), ...args: unknown[]): Promise<DataFrameResult>;
+
+    // Sorting
+    sort_values(by: string | string[], ascending?: boolean | boolean[], inplace?: boolean, na_position?: 'first' | 'last'): Promise<DataFrameResult>;
+    sort_index(axis?: number, level?: number, ascending?: boolean, inplace?: boolean): Promise<DataFrameResult>;
+    rank(axis?: number, method?: 'average' | 'min' | 'max' | 'first' | 'dense', ascending?: boolean): Promise<DataFrameResult>;
+
+    // Missing data
+    isnull(): Promise<DataFrameResult>;
+    isna(): Promise<DataFrameResult>;
+    notna(): Promise<DataFrameResult>;
+    notnull(): Promise<DataFrameResult>;
+    dropna(axis?: number | string, how?: 'any' | 'all', subset?: string[]): Promise<DataFrameResult>;
+    fillna(value?: unknown, method?: 'backfill' | 'bfill' | 'ffill' | 'pad'): Promise<DataFrameResult>;
+    interpolate(method?: string): Promise<DataFrameResult>;
+
+    // Merging
+    merge(right: PyProxy, how?: 'left' | 'right' | 'inner' | 'outer' | 'cross', on?: string | string[], left_on?: string | string[], right_on?: string | string[]): Promise<DataFrameResult>;
+    join(other: PyProxy, on?: string, how?: 'left' | 'right' | 'inner' | 'outer'): Promise<DataFrameResult>;
+    concat(objs: PyProxy[], axis?: number): Promise<DataFrameResult>;
+    append(other: PyProxy | Record<string, unknown>, ignore_index?: boolean): Promise<DataFrameResult>;
+
+    // Statistics
+    describe(include?: string | string[], exclude?: string | string[]): Promise<DataFrameResult>;
+    info(): Promise<void>;
+    mean(axis?: number | string, numeric_only?: boolean): Promise<SeriesResult>;
+    median(axis?: number | string, numeric_only?: boolean): Promise<SeriesResult>;
+    std(axis?: number | string, ddof?: number): Promise<SeriesResult>;
+    var(axis?: number | string, ddof?: number): Promise<SeriesResult>;
+    min(axis?: number | string): Promise<SeriesResult>;
+    max(axis?: number | string): Promise<SeriesResult>;
+    sum(axis?: number | string, skipna?: boolean): Promise<SeriesResult>;
+    count(axis?: number | string): Promise<SeriesResult>;
+    corr(method?: 'pearson' | 'kendall' | 'spearman'): Promise<DataFrameResult>;
+    cov(): Promise<DataFrameResult>;
+    cumsum(axis?: number): Promise<DataFrameResult>;
+    cumprod(axis?: number): Promise<DataFrameResult>;
+    cummax(axis?: number): Promise<DataFrameResult>;
+    cummin(axis?: number): Promise<DataFrameResult>;
+    diff(periods?: number, axis?: number): Promise<DataFrameResult>;
+    pct_change(periods?: number): Promise<DataFrameResult>;
+    quantile(q?: number | number[], axis?: number, numeric_only?: boolean): Promise<DataFrameResult | SeriesResult>;
+    mode(axis?: number, numeric_only?: boolean, dropna?: boolean): Promise<DataFrameResult>;
+    abs(): Promise<DataFrameResult>;
+    clip(lower?: number, upper?: number): Promise<DataFrameResult>;
+    round(decimals?: number | Record<string, number>): Promise<DataFrameResult>;
+
+    // Index operations
+    reset_index(level?: number | string | (number | string)[], drop?: boolean, inplace?: boolean): Promise<DataFrameResult>;
+    set_index(keys: string | string[], drop?: boolean, inplace?: boolean): Promise<DataFrameResult>;
+    reindex(index?: unknown[], columns?: string[], fill_value?: unknown): Promise<DataFrameResult>;
+    rename(columns?: Record<string, string>, index?: Record<unknown, unknown>): Promise<DataFrameResult>;
+    rename_axis(mapper?: string | string[]): Promise<DataFrameResult>;
+    drop(labels?: string | string[], axis?: number | string, columns?: string | string[], index?: unknown[], inplace?: boolean): Promise<DataFrameResult>;
+    drop_duplicates(subset?: string | string[], keep?: 'first' | 'last' | false, inplace?: boolean): Promise<DataFrameResult>;
+    duplicated(subset?: string | string[], keep?: 'first' | 'last' | false): Promise<SeriesResult>;
+
+    // Type conversion
+    astype(dtype: string | Record<string, string>): Promise<DataFrameResult>;
+    convert_dtypes(): Promise<DataFrameResult>;
+    infer_objects(): Promise<DataFrameResult>;
+
+    // Utility
+    copy(deep?: boolean): Promise<DataFrameResult>;
+    equals(other: PyProxy): Promise<boolean>;
+    assign(...kwargs: Record<string, unknown>[]): Promise<DataFrameResult>;
+    eval(expr: string, inplace?: boolean): Promise<DataFrameResult | SeriesResult>;
+    query(expr: string, inplace?: boolean): Promise<DataFrameResult>;
+    items(): Promise<Array<[string, SeriesResult]>>;
+    iterrows(): PyProxy;
+    itertuples(index?: boolean, name?: string): PyProxy;
+    iteritems(): PyProxy;
+    __len__(): Promise<number>;
+    __str__(): Promise<string>;
+    [key: string]: unknown;
+  }
+
+  /**
+   * One-dimensional ndarray with axis labels.
+   */
+  export class Series {
+    constructor(
+      data?: unknown[] | Record<unknown, unknown>,
+      index?: unknown[],
+      dtype?: string,
+      name?: string,
+    );
+
+    readonly name: Promise<string>;
+    readonly dtype: Promise<string>;
+    readonly shape: Promise<[number]>;
+    readonly size: Promise<number>;
+    readonly ndim: Promise<number>;
+    readonly index: Promise<unknown[]>;
+    readonly values: Promise<unknown[]>;
+    readonly empty: Promise<boolean>;
+
+    // Conversion
+    tolist(): Promise<unknown[]>;
+    to_list(): Promise<unknown[]>;
+    to_numpy(): Promise<Float64Array>;
+    to_dict(): Promise<Record<unknown, unknown>>;
+    to_frame(name?: string): Promise<DataFrameResult>;
+    to_json(path_or_buf?: string | null, orient?: string): Promise<string | null>;
+    to_csv(path_or_buf?: string | null): Promise<string | null>;
+    to_string(): Promise<string>;
+
+    // Selection
+    head(n?: number): Promise<SeriesResult>;
+    tail(n?: number): Promise<SeriesResult>;
+    sample(n?: number, frac?: number): Promise<SeriesResult>;
+
+    // Statistics
+    describe(): Promise<SeriesResult>;
+    mean(): Promise<number>;
+    median(): Promise<number>;
+    std(ddof?: number): Promise<number>;
+    var(ddof?: number): Promise<number>;
+    min(): Promise<number>;
+    max(): Promise<number>;
+    sum(skipna?: boolean): Promise<number>;
+    count(): Promise<number>;
+    value_counts(normalize?: boolean, sort?: boolean, ascending?: boolean, dropna?: boolean): Promise<SeriesResult>;
+    unique(): Promise<unknown[]>;
+    nunique(dropna?: boolean): Promise<number>;
+    quantile(q?: number | number[]): Promise<number | SeriesResult>;
+    mode(dropna?: boolean): Promise<SeriesResult>;
+    corr(other: PyProxy, method?: string): Promise<number>;
+    cov(other: PyProxy, min_periods?: number): Promise<number>;
+    abs(): Promise<SeriesResult>;
+    round(decimals?: number): Promise<SeriesResult>;
+    clip(lower?: number, upper?: number): Promise<SeriesResult>;
+    cumsum(): Promise<SeriesResult>;
+    cumprod(): Promise<SeriesResult>;
+    diff(periods?: number): Promise<SeriesResult>;
+    pct_change(periods?: number): Promise<SeriesResult>;
+    rank(method?: string, ascending?: boolean): Promise<SeriesResult>;
+
+    // Transformation
+    apply(func: PyProxy | ((...args: unknown[]) => unknown)): Promise<SeriesResult>;
+    map(arg: PyProxy | Record<unknown, unknown> | ((...args: unknown[]) => unknown)): Promise<SeriesResult>;
+    transform(func: string | ((...args: unknown[]) => unknown)): Promise<SeriesResult>;
+    pipe(func: PyProxy | ((...args: unknown[]) => unknown)): Promise<SeriesResult>;
+
+    // Missing data
+    isnull(): Promise<SeriesResult>;
+    isna(): Promise<SeriesResult>;
+    notna(): Promise<SeriesResult>;
+    dropna(): Promise<SeriesResult>;
+    fillna(value?: unknown, method?: string): Promise<SeriesResult>;
+    interpolate(method?: string): Promise<SeriesResult>;
+
+    // Sorting
+    sort_values(ascending?: boolean, inplace?: boolean): Promise<SeriesResult>;
+    sort_index(ascending?: boolean, inplace?: boolean): Promise<SeriesResult>;
+
+    // Index operations
+    reset_index(drop?: boolean): Promise<SeriesResult | DataFrameResult>;
+    rename(index?: string | Record<unknown, unknown>): Promise<SeriesResult>;
+    reindex(index?: unknown[]): Promise<SeriesResult>;
+    drop(labels: unknown | unknown[]): Promise<SeriesResult>;
+    drop_duplicates(keep?: 'first' | 'last' | false): Promise<SeriesResult>;
+
+    // String operations
+    str: PyProxy;
+    dt: PyProxy;
+    cat: PyProxy;
+    plot: PyProxy;
+
+    // Type
+    astype(dtype: string): Promise<SeriesResult>;
+    copy(deep?: boolean): Promise<SeriesResult>;
+    __len__(): Promise<number>;
+    __str__(): Promise<string>;
+    [key: string]: unknown;
+  }
+
+  /**
+   * Immutable sequence used for indexing and alignment.
+   */
+  export class Index {
+    constructor(data: unknown[], dtype?: string, name?: string);
+    readonly name: Promise<string>;
+    readonly dtype: Promise<string>;
+    readonly shape: Promise<[number]>;
+    tolist(): Promise<unknown[]>;
+    to_list(): Promise<unknown[]>;
+    to_numpy(): Promise<unknown[]>;
+    sort_values(ascending?: boolean): Promise<unknown[]>;
+    unique(): Promise<unknown[]>;
+    [key: string]: unknown;
+  }
+
+  // ── Top-level functions ────────────────────────────────────────────────────
+
+  export function read_csv(
+    filepath_or_buffer: string | PyProxy,
+    sep?: string,
+    delimiter?: string,
+    header?: number | number[] | null,
+    names?: string[],
+    index_col?: string | number | (string | number)[] | false,
+    usecols?: string[] | number[],
+    dtype?: string | Record<string, string>,
+    na_values?: unknown,
+    skiprows?: number | number[],
+    nrows?: number,
+    encoding?: string,
+    compression?: string,
+    chunksize?: number,
+    low_memory?: boolean,
+  ): Promise<DataFrameResult>;
+
+  export function read_excel(
+    io: string | PyProxy,
+    sheet_name?: string | number | (string | number)[] | null,
+    header?: number | null,
+    names?: string[],
+    index_col?: string | number | null,
+    usecols?: string | number[],
+    dtype?: string | Record<string, string>,
+    skiprows?: number | number[],
+    nrows?: number,
+  ): Promise<DataFrameResult | Record<string, DataFrameResult>>;
+
+  export function read_json(
+    path_or_buf: string | PyProxy,
+    orient?: 'records' | 'split' | 'index' | 'columns' | 'values',
+    typ?: 'frame' | 'series',
+    lines?: boolean,
+    chunksize?: number,
+  ): Promise<DataFrameResult | SeriesResult>;
+
+  export function read_parquet(
+    path: string | PyProxy,
+    engine?: 'auto' | 'pyarrow' | 'fastparquet',
+    columns?: string[],
+    filters?: unknown,
+  ): Promise<DataFrameResult>;
+
+  export function read_sql(
+    sql: string | PyProxy,
+    con: PyProxy,
+    index_col?: string | string[],
+    params?: unknown[] | Record<string, unknown>,
+    columns?: string[],
+    chunksize?: number,
+  ): Promise<DataFrameResult>;
+
+  export function read_sql_query(
+    sql: string | PyProxy,
+    con: PyProxy,
+    index_col?: string | null,
+    params?: unknown[] | Record<string, unknown>,
+    chunksize?: number,
+  ): Promise<DataFrameResult>;
+
+  export function read_html(
+    io: string | PyProxy,
+    match?: string | RegExp,
+    header?: number | number[],
+    index_col?: number | number[],
+    attrs?: Record<string, string>,
+  ): Promise<DataFrameResult[]>;
+
+  export function read_clipboard(sep?: string): Promise<DataFrameResult>;
+
+  export function read_feather(path: string | PyProxy): Promise<DataFrameResult>;
+
+  export function read_orc(path: string | PyProxy): Promise<DataFrameResult>;
+
+  export function concat(
+    objs: PyProxy[] | DataFrameResult[],
+    axis?: 0 | 1,
+    join?: 'inner' | 'outer',
+    ignore_index?: boolean,
+    keys?: unknown[],
+    sort?: boolean,
+    copy?: boolean,
+  ): Promise<DataFrameResult>;
+
+  export function merge(
+    left: PyProxy,
+    right: PyProxy,
+    how?: 'left' | 'right' | 'inner' | 'outer' | 'cross',
+    on?: string | string[],
+    left_on?: string | string[],
+    right_on?: string | string[],
+    suffixes?: [string, string],
+    indicator?: boolean,
+    validate?: string,
+  ): Promise<DataFrameResult>;
+
+  export function merge_asof(
+    left: PyProxy,
+    right: PyProxy,
+    on?: string,
+    by?: string | string[],
+    direction?: 'backward' | 'forward' | 'nearest',
+  ): Promise<DataFrameResult>;
+
+  export function pivot_table(
+    data: PyProxy,
+    values?: string | string[],
+    index?: string | string[],
+    columns?: string | string[],
+    aggfunc?: string | ((...args: unknown[]) => unknown) | Record<string, string>,
+    fill_value?: unknown,
+    margins?: boolean,
+  ): Promise<DataFrameResult>;
+
+  export function crosstab(
+    index: PyProxy | unknown[],
+    columns: PyProxy | unknown[],
+    values?: PyProxy,
+    rownames?: string[],
+    colnames?: string[],
+    aggfunc?: string,
+    normalize?: boolean | 'all' | 'index' | 'columns',
+    margins?: boolean,
+  ): Promise<DataFrameResult>;
+
+  export function get_dummies(
+    data: PyProxy,
+    prefix?: string | string[],
+    prefix_sep?: string,
+    dummy_na?: boolean,
+    columns?: string[],
+    drop_first?: boolean,
+    dtype?: string,
+  ): Promise<DataFrameResult>;
+
+  export function to_datetime(
+    arg: string | string[] | number | number[] | PyProxy,
+    errors?: 'raise' | 'coerce' | 'ignore',
+    format?: string,
+    unit?: string,
+    infer_datetime_format?: boolean,
+  ): Promise<SeriesResult | PyProxy>;
+
+  export function to_timedelta(
+    arg: string | string[] | number | number[] | PyProxy,
+    unit?: string,
+    errors?: 'raise' | 'coerce' | 'ignore',
+  ): Promise<SeriesResult | PyProxy>;
+
+  export function isna(obj: unknown): Promise<boolean | DataFrameResult | SeriesResult>;
+  export function isnull(obj: unknown): Promise<boolean | DataFrameResult | SeriesResult>;
+  export function notna(obj: unknown): Promise<boolean | DataFrameResult | SeriesResult>;
+  export function notnull(obj: unknown): Promise<boolean | DataFrameResult | SeriesResult>;
+
+  export function cut(
+    x: PyProxy | unknown[],
+    bins: number | number[],
+    right?: boolean,
+    labels?: string[] | false,
+    retbins?: boolean,
+    precision?: number,
+    include_lowest?: boolean,
+  ): Promise<SeriesResult | PyProxy>;
+
+  export function qcut(
+    x: PyProxy | unknown[],
+    q: number | number[],
+    labels?: string[] | false,
+    retbins?: boolean,
+    precision?: number,
+    duplicates?: 'raise' | 'drop',
+  ): Promise<SeriesResult | PyProxy>;
+
+  export function melt(
+    frame: PyProxy,
+    id_vars?: string | string[],
+    value_vars?: string | string[],
+    var_name?: string,
+    value_name?: string,
+  ): Promise<DataFrameResult>;
+
+  export function wide_to_long(
+    df: PyProxy,
+    stubnames: string | string[],
+    i: string | string[],
+    j: string,
+    sep?: string,
+    suffix?: string,
+  ): Promise<DataFrameResult>;
+
+  export function factorize(
+    values: PyProxy | unknown[],
+    sort?: boolean,
+    na_sentinel?: number | null,
+  ): Promise<[Int32Array, unknown[]]>;
+
+  // ── Groupby ───────────────────────────────────────────────────────────────
+
+  export class GroupBy {
+    agg(func: string | string[] | Record<string, string>): Promise<DataFrameResult>;
+    aggregate(func: string | string[] | Record<string, string>): Promise<DataFrameResult>;
+    apply(func: PyProxy | ((...args: unknown[]) => unknown)): Promise<DataFrameResult>;
+    transform(func: string | ((...args: unknown[]) => unknown)): Promise<DataFrameResult>;
+    filter(func: PyProxy | ((...args: unknown[]) => unknown)): Promise<DataFrameResult>;
+    sum(skipna?: boolean): Promise<DataFrameResult>;
+    mean(numeric_only?: boolean): Promise<DataFrameResult>;
+    median(numeric_only?: boolean): Promise<DataFrameResult>;
+    min(): Promise<DataFrameResult>;
+    max(): Promise<DataFrameResult>;
+    count(): Promise<DataFrameResult>;
+    std(ddof?: number): Promise<DataFrameResult>;
+    var(ddof?: number): Promise<DataFrameResult>;
+    first(): Promise<DataFrameResult>;
+    last(): Promise<DataFrameResult>;
+    head(n?: number): Promise<DataFrameResult>;
+    tail(n?: number): Promise<DataFrameResult>;
+    nth(n: number | number[]): Promise<DataFrameResult>;
+    cumsum(): Promise<DataFrameResult>;
+    cumprod(): Promise<DataFrameResult>;
+    cummax(): Promise<DataFrameResult>;
+    cummin(): Promise<DataFrameResult>;
+    diff(periods?: number): Promise<DataFrameResult>;
+    pct_change(periods?: number): Promise<DataFrameResult>;
+    rank(method?: string, ascending?: boolean): Promise<DataFrameResult>;
+    shift(periods?: number): Promise<DataFrameResult>;
+    size(): Promise<SeriesResult>;
+    ngroups: Promise<number>;
+    groups: Promise<Record<unknown, unknown[]>>;
+    [key: string]: unknown;
+  }
+
+  // ── Period / DatetimeIndex ─────────────────────────────────────────────────
+
+  export function date_range(
+    start?: string | Date,
+    end?: string | Date,
+    periods?: number,
+    freq?: string,
+    tz?: string,
+    normalize?: boolean,
+    name?: string,
+  ): Promise<PyProxy>;
+
+  export function period_range(
+    start?: string,
+    end?: string,
+    periods?: number,
+    freq?: string,
+    name?: string,
+  ): Promise<PyProxy>;
+
+  export function timedelta_range(
+    start?: string,
+    end?: string,
+    periods?: number,
+    freq?: string,
+    name?: string,
+  ): Promise<PyProxy>;
+
+  export function bdate_range(
+    start?: string,
+    end?: string,
+    periods?: number,
+    freq?: string,
+    tz?: string,
+    name?: string,
+  ): Promise<PyProxy>;
+
+  export function Timestamp(
+    ts_input?: string | number | Date,
+    freq?: string,
+    tz?: string,
+    unit?: string,
+  ): Promise<PyProxy>;
+
+  export function Timedelta(
+    value?: string | number,
+    unit?: string,
+    days?: number,
+    hours?: number,
+    minutes?: number,
+    seconds?: number,
+  ): Promise<PyProxy>;
+
+  export function Period(
+    value?: string,
+    freq?: string,
+    ordinal?: number,
+    year?: number,
+    month?: number,
+  ): Promise<PyProxy>;
+
+  // ── Options ────────────────────────────────────────────────────────────────
+
+  export const options: PyProxy;
+  export function set_option(pat: string, value: unknown): Promise<void>;
+  export function get_option(pat: string): Promise<unknown>;
+  export function reset_option(pat: string): Promise<void>;
+
+  // ── Versions ──────────────────────────────────────────────────────────────
+
+  export const __version__: string;
+}
+