presubmit 0.1.0

package/vendor/lancedb/dist/arrow_type.d.ts

@@ -0,0 +1,9 @@
+import { type DataType } from "apache-arrow";
+/**
+ * Map a JS TypedArray instance to the corresponding Arrow element type and
+ * length. Returns undefined when the view is not a supported TypedArray.
+ */
+export declare function typedArrayToArrowType(value: ArrayBufferView): {
+    elementType: DataType;
+    length: number;
+} | undefined;

package/vendor/lancedb/dist/arrow_type.js

@@ -0,0 +1,29 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright The LanceDB Authors
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typedArrayToArrowType = typedArrayToArrowType;
+const apache_arrow_1 = require("apache-arrow");
+/**
+ * Map a JS TypedArray instance to the corresponding Arrow element type and
+ * length. Returns undefined when the view is not a supported TypedArray.
+ */
+function typedArrayToArrowType(value) {
+    if (value instanceof Float32Array)
+        return { elementType: new apache_arrow_1.Float32(), length: value.length };
+    if (value instanceof Float64Array)
+        return { elementType: new apache_arrow_1.Float64(), length: value.length };
+    if (value instanceof Uint8Array)
+        return { elementType: new apache_arrow_1.Uint8(), length: value.length };
+    if (value instanceof Uint16Array)
+        return { elementType: new apache_arrow_1.Uint16(), length: value.length };
+    if (value instanceof Uint32Array)
+        return { elementType: new apache_arrow_1.Uint32(), length: value.length };
+    if (value instanceof Int8Array)
+        return { elementType: new apache_arrow_1.Int8(), length: value.length };
+    if (value instanceof Int16Array)
+        return { elementType: new apache_arrow_1.Int16(), length: value.length };
+    if (value instanceof Int32Array)
+        return { elementType: new apache_arrow_1.Int32(), length: value.length };
+    return undefined;
+}

package/vendor/lancedb/dist/connection.d.ts

@@ -0,0 +1,508 @@
+import { Data, SchemaLike, TableLike } from "./arrow";
+import { Table as ArrowTable } from "./arrow";
+import { EmbeddingFunctionConfig } from "./embedding/registry";
+import { MaterializedView, MaterializedViewSelect } from "./materialized_view";
+import { Connection as LanceDbConnection } from "./native";
+import type { CreateNamespaceResponse, DescribeNamespaceResponse, DropNamespaceResponse, Job, JobDescription, JobInfo, ListNamespacesResponse, ListTablesResponse } from "./native";
+export type { CreateNamespaceResponse, DescribeNamespaceResponse, DropNamespaceResponse, ListNamespacesResponse, ListTablesResponse, };
+import { Table } from "./table";
+export interface CreateTableOptions {
+    /**
+     * The mode to use when creating the table.
+     *
+     * If this is set to "create" and the table already exists then either
+     * an error will be thrown or, if existOk is true, then nothing will
+     * happen.  Any provided data will be ignored.
+     *
+     * If this is set to "overwrite" then any existing table will be replaced.
+     */
+    mode: "create" | "overwrite";
+    /**
+     * If this is true and the table already exists and the mode is "create"
+     * then no error will be raised.
+     */
+    existOk: boolean;
+    /**
+     * Configuration for object storage.
+     *
+     * Options already set on the connection will be inherited by the table,
+     * but can be overridden here.
+     *
+     * The available options are described at https://docs.lancedb.com/storage/
+     */
+    storageOptions?: Record<string, string>;
+    /**
+     * The version of the data storage format to use.
+     *
+     * The default is `stable`.
+     * Set to "legacy" to use the old format.
+     *
+     * @deprecated Pass `new_table_data_storage_version` to storageOptions instead.
+     */
+    dataStorageVersion?: string;
+    /**
+     * Use the new V2 manifest paths. These paths provide more efficient
+     * opening of datasets with many versions on object stores.  WARNING:
+     * turning this on will make the dataset unreadable for older versions
+     * of LanceDB (prior to 0.10.0). To migrate an existing dataset, instead
+     * use the {@link LocalTable#migrateManifestPathsV2} method.
+     *
+     * @deprecated Pass `new_table_enable_v2_manifest_paths` to storageOptions instead.
+     */
+    enableV2ManifestPaths?: boolean;
+    schema?: SchemaLike;
+    embeddingFunction?: EmbeddingFunctionConfig;
+}
+export interface OpenTableOptions {
+    /**
+     * Open the table scoped to this branch instead of the default branch.
+     *
+     * Reads and writes on the returned table operate in the branch's context.
+     */
+    branch?: string;
+    /**
+     * Open the table pinned to this version, producing a read-only view.
+     *
+     * Composes with {@link OpenTableOptions.branch}: when both are set, opens
+     * that branch at the version; otherwise opens `main` at the version. Call
+     * `checkoutLatest` to return to a writable state.
+     */
+    version?: number;
+    /**
+     * Configuration for object storage.
+     *
+     * Options already set on the connection will be inherited by the table,
+     * but can be overridden here.
+     *
+     * The available options are described at https://docs.lancedb.com/storage/
+     */
+    storageOptions?: Record<string, string>;
+    /**
+     * Set the size of the index cache, specified as a number of entries
+     *
+     * @deprecated Use session-level cache configuration instead.
+     * Create a Session with custom cache sizes and pass it to the connect() function.
+     *
+     * The exact meaning of an "entry" will depend on the type of index:
+     * - IVF: there is one entry for each IVF partition
+     * - BTREE: there is one entry for the entire index
+     *
+     * This cache applies to the entire opened table, across all indices.
+     * Setting this value higher will increase performance on larger datasets
+     * at the expense of more RAM
+     */
+    indexCacheSize?: number;
+}
+/**
+ * @deprecated Use {@link ListTablesOptions} with {@link Connection.listTables}
+ * instead.
+ */
+export interface TableNamesOptions {
+    /**
+     * If present, only return names that come lexicographically after the
+     * supplied value.
+     *
+     * This can be combined with limit to implement pagination by setting this to
+     * the last table name from the previous page.
+     */
+    startAfter?: string;
+    /** An optional limit to the number of results to return. */
+    limit?: number;
+}
+export interface ListTablesOptions {
+    /**
+     * Token from a previous response, to resume listing where it left off.
+     *
+     * The token is opaque: it carries whatever the database needs to resume, and
+     * callers should not construct or interpret one.
+     */
+    pageToken?: string;
+    /**
+     * An upper bound on how many tables to return.
+     *
+     * A page may hold fewer than this and still not be the last one, so keep
+     * going while the response carries a page token rather than while pages are
+     * full.
+     */
+    limit?: number;
+}
+export interface ListNamespacesOptions {
+    /** Token from a previous response for pagination. */
+    pageToken?: string;
+    /** An optional limit to the number of results to return. */
+    limit?: number;
+}
+export interface CreateNamespaceOptions {
+    /** Creation mode. */
+    mode?: "create" | "exist_ok" | "overwrite";
+    /** Properties to set on the new namespace. */
+    properties?: Record<string, string>;
+}
+export interface DropNamespaceOptions {
+    /** Whether to skip if the namespace doesn't exist, or fail. */
+    mode?: "skip" | "fail";
+    /** Refuse to drop if non-empty (restrict) or drop recursively (cascade). */
+    behavior?: "restrict" | "cascade";
+}
+export interface RenameTableOptions {
+    /**
+     * The namespace path of the table being renamed. Defaults to the root
+     * namespace (`[]`) when omitted.
+     */
+    namespacePath?: string[];
+    /**
+     * The namespace path to move the table to as part of the rename. When
+     * omitted the table stays in `namespacePath`.
+     */
+    newNamespacePath?: string[];
+}
+/**
+ * A LanceDB Connection that allows you to open tables and create new ones.
+ *
+ * Connection could be local against filesystem or remote against a server.
+ *
+ * A Connection is intended to be a long lived object and may hold open
+ * resources such as HTTP connection pools.  This is generally fine and
+ * a single connection should be shared if it is going to be used many
+ * times. However, if you are finished with a connection, you may call
+ * close to eagerly free these resources.  Any call to a Connection
+ * method after it has been closed will result in an error.
+ *
+ * Closing a connection is optional.  Connections will automatically
+ * be closed when they are garbage collected.
+ *
+ * Any created tables are independent and will continue to work even if
+ * the underlying connection has been closed.
+ * @hideconstructor
+ */
+export declare abstract class Connection {
+    /**
+     * Return true if the connection has not been closed
+     */
+    abstract isOpen(): boolean;
+    /**
+     * Close the connection, releasing any underlying resources.
+     *
+     * It is safe to call this method multiple times.
+     *
+     * Any attempt to use the connection after it is closed will result in an error.
+     */
+    abstract close(): void;
+    /**
+     * Return a brief description of the connection
+     */
+    abstract display(): string;
+    /**
+     * List all the table names in this database.
+     *
+     * Tables will be returned in lexicographical order.
+     * @param {Partial<TableNamesOptions>} options - options to control the
+     * paging / start point (backwards compatibility)
+     *
+     * @deprecated Use {@link Connection.listTables} instead.
+     */
+    abstract tableNames(options?: Partial<TableNamesOptions>): Promise<string[]>;
+    /**
+     * List all the table names in this database.
+     *
+     * Tables will be returned in lexicographical order.
+     * @param {string[]} namespacePath - The namespace path to list tables from (defaults to root namespace)
+     * @param {Partial<TableNamesOptions>} options - options to control the
+     * paging / start point
+     *
+     * @deprecated Use {@link Connection.listTables} instead.
+     */
+    abstract tableNames(namespacePath?: string[], options?: Partial<TableNamesOptions>): Promise<string[]>;
+    /**
+     * List a page of the tables in this database.
+     *
+     * To retrieve the tables after the page, pass the `pageToken` the response
+     * carries back in. A page can be shorter than `limit` without being the last
+     * one, so walk until a response carries no page token:
+     *
+     * ```ts
+     * const names = [];
+     * let pageToken = undefined;
+     * do {
+     *   const page = await conn.listTables({ pageToken, limit: 100 });
+     *   names.push(...page.tables);
+     *   pageToken = page.pageToken;
+     * } while (pageToken);
+     * ```
+     *
+     * @param {Partial<ListTablesOptions>} options - Pagination options
+     *   (`pageToken`, `limit`).
+     * @returns {Promise<ListTablesResponse>} A page of table names and an
+     *   optional token for the tables after it.
+     */
+    abstract listTables(options?: Partial<ListTablesOptions>): Promise<ListTablesResponse>;
+    /**
+     * List a page of the tables in this database.
+     *
+     * @param {string[]} namespacePath - The namespace path to list tables from
+     *   (defaults to root namespace)
+     * @param {Partial<ListTablesOptions>} options - Pagination options
+     *   (`pageToken`, `limit`).
+     * @returns {Promise<ListTablesResponse>} A page of table names and an
+     *   optional token for the tables after it.
+     */
+    abstract listTables(namespacePath?: string[], options?: Partial<ListTablesOptions>): Promise<ListTablesResponse>;
+    /**
+     * Open a table in the database.
+     * @param {string} name - The name of the table
+     * @param {string[]} namespacePath - The namespace path of the table (defaults to root namespace)
+     * @param {Partial<OpenTableOptions>} options - Additional options
+     */
+    /**
+     * Define a materialized view named `name` over the table `source`.
+     *
+     * The view is created empty, with the query recorded in its schema
+     * metadata; `view.refresh()` computes the rows. The view is a normal
+     * table: it can be queried, indexed and searched, and it appears in
+     * `tableNames`. The source table must have stable row ids (create it with
+     * the `newTableEnableStableRowIds` storage option); they keep the view's
+     * provenance valid across source compactions and cannot be enabled after
+     * a table exists. Local databases only.
+     */
+    abstract createMaterializedView(name: string, source: string, options?: {
+        select?: MaterializedViewSelect;
+        where?: string;
+        limit?: number;
+    }): Promise<MaterializedView>;
+    /**
+     * Open the materialized view named `name`.
+     *
+     * Rejects a table that exists but is not a materialized view.
+     */
+    abstract openMaterializedView(name: string): Promise<MaterializedView>;
+    /**
+     * The names of the materialized views in this database.
+     *
+     * Found by reading every table's schema, so this costs an open per table.
+     */
+    abstract listMaterializedViews(): Promise<string[]>;
+    abstract openTable(name: string, namespacePath?: string[], options?: Partial<OpenTableOptions>): Promise<Table>;
+    /**
+     * Creates a new Table and initialize it with new data.
+     * @param {object} options - The options object.
+     * @param {string} options.name - The name of the table.
+     * @param {Data} options.data - Non-empty Array of Records to be inserted into the table
+     * @param {string[]} namespacePath - The namespace path to create the table in (defaults to root namespace)
+     *
+     */
+    abstract createTable(options: {
+        name: string;
+        data: Data;
+    } & Partial<CreateTableOptions>, namespacePath?: string[]): Promise<Table>;
+    /**
+     * Creates a new Table and initialize it with new data.
+     * @param {string} name - The name of the table.
+     * @param {Record<string, unknown>[] | TableLike} data - Non-empty Array of Records
+     * to be inserted into the table
+     * @param {Partial<CreateTableOptions>} options - Additional options (backwards compatibility)
+     */
+    abstract createTable(name: string, data: Record<string, unknown>[] | TableLike, options?: Partial<CreateTableOptions>): Promise<Table>;
+    /**
+     * Creates a new Table and initialize it with new data.
+     * @param {string} name - The name of the table.
+     * @param {Record<string, unknown>[] | TableLike} data - Non-empty Array of Records
+     * to be inserted into the table
+     * @param {string[]} namespacePath - The namespace path to create the table in (defaults to root namespace)
+     * @param {Partial<CreateTableOptions>} options - Additional options
+     */
+    abstract createTable(name: string, data: Record<string, unknown>[] | TableLike, namespacePath?: string[], options?: Partial<CreateTableOptions>): Promise<Table>;
+    /**
+     * Creates a new empty Table
+     * @param {string} name - The name of the table.
+     * @param {Schema} schema - The schema of the table
+     * @param {Partial<CreateTableOptions>} options - Additional options (backwards compatibility)
+     */
+    abstract createEmptyTable(name: string, schema: import("./arrow").SchemaLike, options?: Partial<CreateTableOptions>): Promise<Table>;
+    /**
+     * Creates a new empty Table
+     * @param {string} name - The name of the table.
+     * @param {Schema} schema - The schema of the table
+     * @param {string[]} namespacePath - The namespace path to create the table in (defaults to root namespace)
+     * @param {Partial<CreateTableOptions>} options - Additional options
+     */
+    abstract createEmptyTable(name: string, schema: import("./arrow").SchemaLike, namespacePath?: string[], options?: Partial<CreateTableOptions>): Promise<Table>;
+    /**
+     * Drop an existing table.
+     * @param {string} name The name of the table to drop.
+     * @param {string[]} namespacePath The namespace path of the table (defaults to root namespace).
+     */
+    abstract dropTable(name: string, namespacePath?: string[]): Promise<void>;
+    /**
+     * Start dropping a table and return its cleanup job.
+     *
+     * The table may become unavailable before its data files are removed. Wait
+     * on the returned job to know when cleanup has finished.
+     */
+    abstract dropTableAsync(name: string, namespacePath?: string[]): Promise<Job>;
+    /**
+     * Drop all tables in the database.
+     * @param {string[]} namespacePath The namespace path to drop tables from (defaults to root namespace).
+     */
+    abstract dropAllTables(namespacePath?: string[]): Promise<void>;
+    /**
+     * Describe a namespace, returning its properties.
+     *
+     * @param {string[]} namespacePath - The namespace path to describe, in
+     *   parent → child order, e.g. `["analytics", "sales"]`.
+     * @returns {Promise<DescribeNamespaceResponse>} The namespace's properties
+     *   (may be undefined if the namespace has none).
+     */
+    abstract describeNamespace(namespacePath: string[]): Promise<DescribeNamespaceResponse>;
+    /**
+     * List the immediate child namespaces under the given parent.
+     *
+     * Results may be paginated. To retrieve subsequent pages, pass the
+     * `pageToken` returned by a previous call.
+     *
+     * @param {string[]} namespacePath - The parent namespace path. Defaults
+     *   to the root namespace if omitted.
+     * @param {Partial<ListNamespacesOptions>} options - Pagination options
+     *   (`pageToken`, `limit`).
+     * @returns {Promise<ListNamespacesResponse>} Child namespace names and
+     *   an optional token for fetching the next page.
+     */
+    abstract listNamespaces(namespacePath?: string[], options?: Partial<ListNamespacesOptions>): Promise<ListNamespacesResponse>;
+    /**
+     * Create a new namespace at the given path.
+     *
+     * @param {string[]} namespacePath - The namespace path to create.
+     * @param {Partial<CreateNamespaceOptions>} options - Creation `mode`
+     *   ("create" | "exist_ok" | "overwrite") and optional `properties`
+     *   to attach to the namespace.
+     * @returns {Promise<CreateNamespaceResponse>} The properties of the
+     *   created namespace and an optional transaction id.
+     */
+    abstract createNamespace(namespacePath: string[], options?: Partial<CreateNamespaceOptions>): Promise<CreateNamespaceResponse>;
+    /**
+     * Drop a namespace.
+     *
+     * Use `behavior: "cascade"` to also drop everything contained in the
+     * namespace (sub-namespaces and tables). The default `"restrict"`
+     * behavior refuses to drop a non-empty namespace.
+     *
+     * @param {string[]} namespacePath - The namespace path to drop.
+     * @param {Partial<DropNamespaceOptions>} options - `mode` ("skip" | "fail"
+     *   for missing-namespace handling) and `behavior` ("restrict" | "cascade").
+     * @returns {Promise<DropNamespaceResponse>} Any properties returned by
+     *   the server and an optional transaction id.
+     */
+    abstract dropNamespace(namespacePath: string[], options?: Partial<DropNamespaceOptions>): Promise<DropNamespaceResponse>;
+    /**
+     * Clone a table from a source table.
+     *
+     * A shallow clone creates a new table that shares the underlying data files
+     * with the source table but has its own independent manifest. This allows
+     * both the source and cloned tables to evolve independently while initially
+     * sharing the same data, deletion, and index files.
+     *
+     * @param {string} targetTableName - The name of the target table to create.
+     * @param {string} sourceUri - The URI of the source table to clone from.
+     * @param {object} options - Clone options.
+     * @param {string[]} options.targetNamespacePath - The namespace path for the target table (defaults to root namespace).
+     * @param {number} options.sourceVersion - The version of the source table to clone.
+     * @param {string} options.sourceTag - The tag of the source table to clone.
+     * @param {boolean} options.isShallow - Whether to perform a shallow clone (defaults to true).
+     */
+    abstract cloneTable(targetTableName: string, sourceUri: string, options?: {
+        targetNamespacePath?: string[];
+        sourceVersion?: number;
+        sourceTag?: string;
+        isShallow?: boolean;
+    }): Promise<Table>;
+    /**
+     * Rename a table.
+     *
+     * Currently only supported by LanceDB Cloud. Local OSS connections and
+     * namespace-backed connections (via {@link connectNamespace}) reject with
+     * a "not supported" error.
+     *
+     * @param {string} currentName - The current name of the table.
+     * @param {string} newName - The new name for the table.
+     * @param {RenameTableOptions} options - Optional namespace paths. When
+     *   `newNamespacePath` is omitted the table stays in `namespacePath`.
+     */
+    abstract renameTable(currentName: string, newName: string, options?: RenameTableOptions): Promise<void>;
+    /**
+     * A {@link Job} handle for a server-side job by id.
+     *
+     * The handle is constructed without a server round trip; an unknown id
+     * surfaces when the handle is used. Dropping the handle has no effect on
+     * the job itself.
+     */
+    abstract job(jobId: string): Job;
+    /** List server-side jobs across the database's tables. */
+    abstract listJobs(): Promise<JobInfo[]>;
+    /**
+     * Describe a single server-side job by id.
+     *
+     * Resolves to `null` when the server has no such job.
+     */
+    abstract getJob(jobId: string): Promise<JobDescription | null>;
+    /**
+     * Request cancellation of a server-side job by id.
+     *
+     * Resolves to true if the server accepted the cancellation, false if no
+     * such job exists. Cancelling an already-terminal job is a no-op success.
+     */
+    abstract cancelJob(jobId: string): Promise<boolean>;
+    /**
+     * The lifecycle event history of a server-side job, as an Arrow table.
+     *
+     * Lists history across all jobs when `jobId` is omitted.
+     */
+    abstract jobHistory(jobId?: string): Promise<ArrowTable>;
+}
+/** @hideconstructor */
+export declare class LocalConnection extends Connection {
+    readonly inner: LanceDbConnection;
+    /** @hidden */
+    constructor(inner: LanceDbConnection);
+    isOpen(): boolean;
+    close(): void;
+    display(): string;
+    tableNames(namespacePathOrOptions?: string[] | Partial<TableNamesOptions>, options?: Partial<TableNamesOptions>): Promise<string[]>;
+    createMaterializedView(name: string, source: string, options?: {
+        select?: MaterializedViewSelect;
+        where?: string;
+        limit?: number;
+    }): Promise<MaterializedView>;
+    openMaterializedView(name: string): Promise<MaterializedView>;
+    listMaterializedViews(): Promise<string[]>;
+    listTables(namespacePathOrOptions?: string[] | Partial<ListTablesOptions>, options?: Partial<ListTablesOptions>): Promise<ListTablesResponse>;
+    openTable(name: string, namespacePath?: string[], options?: Partial<OpenTableOptions>): Promise<Table>;
+    cloneTable(targetTableName: string, sourceUri: string, options?: {
+        targetNamespacePath?: string[];
+        sourceVersion?: number;
+        sourceTag?: string;
+        isShallow?: boolean;
+    }): Promise<Table>;
+    private getStorageOptions;
+    createTable(nameOrOptions: string | ({
+        name: string;
+        data: Data;
+    } & Partial<CreateTableOptions>), dataOrNamespacePath?: Record<string, unknown>[] | TableLike | string[], namespacePathOrOptions?: string[] | Partial<CreateTableOptions>, options?: Partial<CreateTableOptions>): Promise<Table>;
+    private _createTableImpl;
+    createEmptyTable(name: string, schema: import("./arrow").SchemaLike, namespacePathOrOptions?: string[] | Partial<CreateTableOptions>, options?: Partial<CreateTableOptions>): Promise<Table>;
+    dropTable(name: string, namespacePath?: string[]): Promise<void>;
+    dropTableAsync(name: string, namespacePath?: string[]): Promise<Job>;
+    dropAllTables(namespacePath?: string[]): Promise<void>;
+    describeNamespace(namespacePath: string[]): Promise<DescribeNamespaceResponse>;
+    listNamespaces(namespacePath?: string[], options?: Partial<ListNamespacesOptions>): Promise<ListNamespacesResponse>;
+    createNamespace(namespacePath: string[], options?: Partial<CreateNamespaceOptions>): Promise<CreateNamespaceResponse>;
+    dropNamespace(namespacePath: string[], options?: Partial<DropNamespaceOptions>): Promise<DropNamespaceResponse>;
+    renameTable(currentName: string, newName: string, options?: RenameTableOptions): Promise<void>;
+    job(jobId: string): Job;
+    listJobs(): Promise<JobInfo[]>;
+    getJob(jobId: string): Promise<JobDescription | null>;
+    cancelJob(jobId: string): Promise<boolean>;
+    jobHistory(jobId?: string): Promise<ArrowTable>;
+}
+/**
+ * Takes storage options and makes all the keys snake case.
+ */
+export declare function cleanseStorageOptions(options?: Record<string, string>): Record<string, string> | undefined;