kQjwddlmZddlmZddlZddlmZddlmZddl Z ddl m Z m Z m Z mZmZmZmZmZmZmZmZddlmZe j0dk\rdd l mZGd d Zndd lmZmZdd lmZmZmZm Z m!Z!m"Z"m#Z#ddl$m%Z%ddl&m'Z'm(Z(m)Z)ddl*m+Z+ddl,m-Z-m.Z.m/Z/m0Z0m1Z2ddl3m4Z4m5Z5ddl6m7Z7ddl8m1Z9ddl:m;Z;mZ>m?Z?m@Z@ddlAmBZCddlAmDZEddlAmFZFmGZGmHZHddlImJZJmKZKmLZLmMZMmNZNddlOmPZPmQZQmRZRmSZSddlTmUZUmVZVmWZWmXZXddlYmZZZm[Z[ddl\m]Z]ddl^Z^e r0ddl_Z`dd lambZbdd!lcmdZddd"l8meZfdd#l8mgZgdd$lhmiZimjZjdd%lkmlZldd&l8mmZmdd'lnmoZompZpmqZq d/d(ZrGd)d*eZsGd+d,esZtGd-d.euZvy)0) annotations)abstractmethodN) timedelta)Path) TYPE_CHECKINGAnyDict GeneratorIterableListLiteralOptionalSequenceTupleUnion)UUID) )overridec eZdZy)EnforceOverridesN)__name__ __module__ __qualname__O/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/lancedb/db.pyrrs rr)rr) AsyncListingAsyncNamespaceListingAsyncTableListingListingNamespaceListing TableListingvalidate_page_limit)EmbeddingFunctionRegistry)data_to_reader sanitize_urivalidate_schema)LOOP)LanceNamespaceCreateNamespaceResponseDropNamespaceResponseDescribeNamespaceResponseconnect)NamespaceNotEmptyErrorTableNotFoundError) __version__)r.)FunctionVersion UdfDefinition)AsyncJobJob _typed_job) AsyncQuery)Query)QueryDescriptionQueryParametersto_parameter_batch)AsyncMaterializedViewMaterializedViewMaterializedViewSource SelectArgnormalize_select) EnvVarSecret SecretInfovalidate_namespace_pathvalidate_secret_name) AsyncTable LanceTableTablesanitize_create_table)get_uri_schemevalidate_table_nameViewDescription)AsyncRecordBatchReader) LanceModel) Connection)JobInfo)DATAURI)EmbeddingFunctionConfig)Session) _normalize_create_namespace_mode_normalize_drop_namespace_mode"_normalize_drop_namespace_behaviorc6|\}}}}}}t||||||S)z1Name the fields the binding returns positionally.)namequerydefault_databaseschemanamespace_pathdefault_namespace_pathrL) describedrZr^r[r\r_r]s r_view_descriptionrams=     )%5  rceZdZdZdDdZdEdZedFdZedEdZ dG dHdZ dI dJdZ dI dKd Z dLd Z dMd Z dNd Z dG dOd Ze dIdd dPdZe dQddddd dRdZdSdZdddddd dTdZddddddd dUdZddddddd dVdZdWdZddd dXdZ dY dZdZ dY d[dZdYd\dZ dY d]dZ dI d^d Zd!ZdYd_d"Zed`d#Z dad$Z!dbd%Z"dcd&Z#ddd'Z$d`d(Z%ddd) ded*Z&ddd) dfd+Z'dd dgd,Z(dddd- dhd.Z)dd did/Z*dd djd0Z+dd dkd1Z,dd dkd2Z-dddd- dld3Z.dd dZd4Z/dd dmd5Z0dd dnd6Z1dd dod7Z2dd dZd8Z3dd dpd9Z4dddd- dld:Z5dqd;Z6ddd drd<Z7dsd=Z8dtd>Z9dtd?Z:ddd@ dudAZ;ddd@ dvdBZ>> import lancedb >>> with lancedb.connect("memory://") as db: ... assert db.is_open() >>> db.is_open() False c|SNrselfs r __enter__zDBConnection.__enter__ rc$|jyrecloserg_s r__exit__zDBConnection.__exit__  rcy)&Return True if the connection is open.Nrrfs ris_openzDBConnection.is_opens rcy)aClose the connection, releasing any underlying resources. It is safe to call this method multiple times. Database operations on a closed connection raise ``RuntimeError: Connection is closed``. Examples -------- >>> import lancedb >>> db = lancedb.connect("memory://") >>> db.close() >>> db.is_open() False Nrrfs rrlzDBConnection.closes rNc6|g}ttddS)aList immediate child namespace names in the given namespace. Parameters ---------- namespace_path: List[str], default [] The parent namespace to list namespaces in. Empty list represents root namespace. page_token: str, optional Token for pagination. Use the token from a previous response to get the next page of results. limit: int, optional The maximum number of results to return. Returns ------- NamespaceListing Response containing namespace names and optional page_token for pagination. NTempty)r"rrgr^ page_tokenlimits rlist_namespaceszDBConnection.list_namespacess"0  !N 5d$ GHHrctd)a2Create a new namespace. Parameters ---------- namespace_path: List[str] The namespace identifier to create. mode: str, optional Creation mode - "create" (fail if exists), "exist_ok" (skip if exists), or "overwrite" (replace if exists). Case insensitive. properties: Dict[str, str], optional Properties to set on the namespace. Returns ------- CreateNamespaceResponse Response containing the properties of the created namespace. ?Namespace operations are not supported for this connection typeNotImplementedErrorrgr^mode propertiess rcreate_namespacezDBConnection.create_namespace." M  rctd)%Drop a namespace. Parameters ---------- namespace_path: List[str] The namespace identifier to drop. mode: str, optional Whether to skip if not exists ("SKIP") or fail ("FAIL"). Case insensitive. behavior: str, optional Whether to restrict drop if not empty ("RESTRICT") or cascade ("CASCADE"). Case insensitive. Returns ------- DropNamespaceResponse Response containing properties and transaction_id if applicable. r}r~)rgr^rbehaviors rdrop_namespacezDBConnection.drop_namespacerrctd)Describe a namespace. Parameters ---------- namespace_path: List[str] The namespace identifier to describe. Returns ------- DescribeNamespaceResponse Response containing the namespace properties. r}r~rgr^s rdescribe_namespacezDBConnection.describe_namespaces" M  rctd)aCheck if a namespace exists. Parameters ---------- namespace_id: List[str] The namespace identifier to check. Returns ------- bool True if the namespace exists, False otherwise. Raises ------ NotImplementedError If the connection type does not support namespace operations. r}r~)rg namespace_ids rnamespace_existszDBConnection.namespace_existss$" M  rctd)aCheck if a table exists. Parameters ---------- table_id: List[str] The table identifier to check (full path including namespace segments and table name). Returns ------- bool True if the table exists, False otherwise. Raises ------ NotImplementedError If the connection type does not support namespace operations. r}r~)rgtable_ids r table_existszDBConnection.table_exists*s&" M  rctd)List tables in this database, one page at a time. Parameters ---------- namespace_path: List[str], optional The namespace to list tables in. None or empty list represents root namespace. page_token: str, optional Token for pagination. Use the token from a previous response to get the next page of results. limit: int, optional The maximum number of results to return, default 100. Zero returns an empty page without a continuation token. Returns ------- TableListing Response containing table names and optional page_token for pagination. z5list_tables is not supported for this connection typer~rxs r list_tableszDBConnection.list_tablesAs2" C  rr^cy)aList all tables in this database, in sorted order Parameters ---------- namespace_path: List[str], default [] The namespace to list tables in. Empty list represents root namespace. page_token: str, optional The token to use for pagination. If not present, start from the beginning. Typically, this token is last table name from the previous page. limit: int, optional The maximum number of tables to return. None returns all tables; zero returns an empty list. Returns ------- Iterable of str Nr)rgryrzr^s r table_nameszDBConnection.table_names^s4 rFr^storage_optionsdata_storage_versionenable_v2_manifest_pathsc td)aKCreate a [Table][lancedb.table.Table] in the database. Parameters ---------- name: str The name of the table. namespace_path: List[str], default [] The namespace to create the table in. Empty list represents root namespace. data: The data to initialize the table, *optional* User must provide at least one of `data` or `schema`. Acceptable types are: - list-of-dict - pandas.DataFrame - pyarrow.Table or pyarrow.RecordBatch schema: The schema of the table, *optional* Acceptable types are: - pyarrow.Schema - [LanceModel][lancedb.pydantic.LanceModel] mode: str; default "create" The mode to use when creating the table. Can be "create", "overwrite", or "exist_ok". By default, if the table already exists, an exception is raised. If you want to overwrite the table, use mode="overwrite". To open an existing table without adding data, use mode="exist_ok". exist_ok: bool, default False If a table by the same name already exists, then raise an exception if exist_ok=False. If exist_ok=True, then open the existing table; it will not add the provided data but will validate against any schema that's specified. on_bad_vectors: str, default "error" How to handle vectors with incorrect sizes, NaNs, or null elements. One of "error", "drop", "fill", "null". fill_value: float The value to use when filling vectors. Only used if on_bad_vectors="fill". NaN or null elements and missing trailing elements are replaced with this value. Valid elements are preserved, and vectors longer than the expected dimension are truncated. storage_options: dict, optional Additional options for the storage backend. Options already set on the connection will be inherited by the table, but can be overridden here. See available options at To enable stable row IDs (row IDs remain stable after compaction, update, delete, and merges), set `new_table_enable_stable_row_ids` to `"true"` in storage_options when connecting to the database. data_storage_version: optional, str, default "stable" Deprecated. Set `storage_options` when connecting to the database and set `new_table_data_storage_version` in the options. enable_v2_manifest_paths: optional, bool, default False Deprecated. Set `storage_options` when connecting to the database and set `new_table_enable_v2_manifest_paths` in the options. Returns ------- LanceTable A reference to the newly created table. !!! note The vector index won't be created by default. To create the index, call the `create_index` method on the table. Examples -------- Can create with list of tuples or dictionaries: >>> import lancedb >>> db = lancedb.connect("./.lancedb") >>> data = [{"vector": [1.1, 1.2], "lat": 45.5, "long": -122.7}, ... {"vector": [0.2, 1.8], "lat": 40.1, "long": -74.1}] >>> db.create_table("my_table", data) LanceTable(name='my_table', ...) >>> db["my_table"].head() pyarrow.Table vector: fixed_size_list[2] child 0, item: float lat: double long: double ---- vector: [[[1.1,1.2],[0.2,1.8]]] lat: [[45.5,40.1]] long: [[-122.7,-74.1]] You can also pass a pandas DataFrame: >>> import pandas as pd >>> data = pd.DataFrame({ ... "vector": [[1.1, 1.2], [0.2, 1.8]], ... "lat": [45.5, 40.1], ... "long": [-122.7, -74.1] ... }) >>> db.create_table("table2", data) LanceTable(name='table2', ...) >>> db["table2"].head() pyarrow.Table vector: fixed_size_list[2] child 0, item: float lat: double long: double ---- vector: [[[1.1,1.2],[0.2,1.8]]] lat: [[45.5,40.1]] long: [[-122.7,-74.1]] Data is converted to Arrow before being written to disk. For maximum control over how data is saved, either provide the PyArrow schema to convert to or else provide a [PyArrow Table][pyarrow.Table] directly. >>> import pyarrow as pa >>> custom_schema = pa.schema([ ... pa.field("vector", pa.list_(pa.float32(), 2)), ... pa.field("lat", pa.float32()), ... pa.field("long", pa.float32()) ... ]) >>> db.create_table("table3", data, schema = custom_schema) LanceTable(name='table3', ...) >>> db["table3"].head() pyarrow.Table vector: fixed_size_list[2] child 0, item: float lat: float long: float ---- vector: [[[1.1,1.2],[0.2,1.8]]] lat: [[45.5,40.1]] long: [[-122.7,-74.1]] It is also possible to create an table from `[Iterable[pa.RecordBatch]]`: >>> import pyarrow as pa >>> def make_batches(): ... for i in range(5): ... yield pa.RecordBatch.from_arrays( ... [ ... pa.array([[3.1, 4.1], [5.9, 26.5]], ... pa.list_(pa.float32(), 2)), ... pa.array(["foo", "bar"]), ... pa.array([10.0, 20.0]), ... ], ... ["vector", "item", "price"], ... ) >>> schema=pa.schema([ ... pa.field("vector", pa.list_(pa.float32(), 2)), ... pa.field("item", pa.utf8()), ... pa.field("price", pa.float32()), ... ]) >>> db.create_table("table4", make_batches(), schema=schema) LanceTable(name='table4', ...) z6create_table is not supported for this connection typer~) rgrZdatar]rexist_okon_bad_vectors fill_valueembedding_functionsr^rrrs r create_tablezDBConnection.create_tablezs`" D  rc$|j|Sre) open_tablergrZs r __getitem__zDBConnection.__getitem__.st$$rr^rindex_cache_sizebranchversionctd)aTOpen a Lance Table in the database. Parameters ---------- name: str The name of the table. namespace_path: List[str], optional The namespace to open the table from. None or empty list represents root namespace. index_cache_size: int, default 256 **Deprecated**: Use session-level cache configuration instead. Create a Session with custom cache sizes and pass it to lancedb.connect(). Set the size of the index cache, specified as a number of entries 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 storage_options: dict, optional Additional options for the storage backend. Options already set on the connection will be inherited by the table, but can be overridden here. See available options at branch: str, optional If provided, open a handle scoped to this branch instead of the default branch. Reads and writes operate in the branch's context. version: int, optional If provided, open the table pinned to this version, producing a read-only handle. Composes with ``branch``: when both are given, opens that branch at the version; otherwise opens ``main`` at the version. Call ``checkout_latest`` to return to a writable state. Returns ------- A LanceTable object representing the table. z4open_table is not supported for this connection typer~)rgrZr^rrrrs rrzDBConnection.open_table1sd" B  rselectwhererz with_no_dataauto_refresh_enabledauto_refresh_interval_secondsctd)aDefine a materialized view named ``name`` over the table ``source``. Local creation and refresh require a source build with the ``experimental-functions`` Cargo feature. Published packages leave it disabled; remote Cloud/Enterprise operations remain available. The view is populated before creation returns. Pass ``with_no_data=True`` to create only its definition and empty backing table. The view is a normal table: it can be queried, indexed and searched, and it appears in ``table_names``. Parameters ---------- name: str The name of the view. source: str The name of the source table. select: list or dict, optional The view's columns: column names, ``(alias, SQL expression)`` pairs, or a dict of the same. Omitting it selects every source column, expanded against the source schema at creation time. where: str, optional SQL predicate; only matching source rows appear in the view. limit: int, optional Cap the view at this many rows, in materialization order. with_no_data: bool, default False Skip the initial refresh and leave the backing table empty. auto_refresh_enabled: bool, optional Enable or disable automatic refresh on Cloud and Enterprise. When omitted, the server determines whether automatic refresh is enabled. Embedded databases do not support automatic refresh. auto_refresh_interval_seconds: float, optional Positive, finite refresh interval in seconds on Cloud and Enterprise. When omitted, the server determines when to refresh. Returns ------- MaterializedView H & &!,,J  &s %><>cBtd|jDS)zCReturn the number of tables in the root namespace across all pages.c3 K|]}dyw)r1Nr).0rns r z'DBConnection.__len__..Ks616s )sumrrfs r__len__zDBConnection.__len__Is6d335666rc&||jvS)z;Return whether the root namespace contains the named table.)rrs r __contains__zDBConnection.__contains__Mst,,...rctd) Get the equivalent namespace client for this connection. For native storage connections, this returns a DirectoryNamespace pointing to the same root with the same storage options. For namespace connections, this returns the backing namespace client. For enterprise (remote) connections, this returns a RestNamespace with the same URI and authentication headers. Returns ------- LanceNamespace The namespace client for this connection. z:namespace_client is not supported for this connection typer~rfs rnamespace_clientzDBConnection.namespace_clientQs " H  rctd)a3Serialize this connection for reconstruction. The returned string can be passed to :func:`lancedb.deserialize_conn` to recreate an equivalent connection, e.g. in a remote worker. Returns ------- str Serialized representation of this connection. z3serialize is not supported for this connection typer~rfs r serializezDBConnection.serializees""WXXrsecretsr^cF|j|||jS)aBuild and register a scalar Python UDF, then return its version. The server builds the OCI image and registers the completed artifact. This is the blocking counterpart of :meth:`create_function_async`. Local connections raise ``NotImplementedError``. Parameters ---------- definition : UdfDefinition A callable decorated with [udf][lancedb.udf]. secrets : sequence of EnvVarSecret, optional One [EnvVarSecret][lancedb.secrets.EnvVarSecret] per credential the Function needs, each naming a Secret and the environment variable its value arrives in. The Function's source is unchanged by this; it reads the variable the way it already did. namespace_path : list of str, optional The namespace holding the Function. None or an empty list is the root namespace. Examples -------- ```python db.create_secret("openai-prod", os.environ["OPENAI_API_KEY"]) db.create_function( analyze_caption, secrets=[ EnvVarSecret( secret_name="openai-prod", env_variable="OPENAI_API_KEY" ) ], ) ``` r)create_function_asyncwaitrg definitionrr^s rcreate_functionzDBConnection.create_functionrs+P)) * $& rctd)aSubmit a scalar Python UDF for building and registration. The server-side job builds the OCI image, then registers the completed artifact. Waiting on the job returns the immutable Function version. Local connections raise ``NotImplementedError``. FFunction catalog operations are not supported for this connection typer~rs rrz"DBConnection.create_function_asyncs" T  rctd)BOpen one exact immutable Function version from the remote catalog.rr~rgrZrr^s r get_functionzDBConnection.get_functions" T  rr^ryrctd)aList every published immutable Function version in a namespace. Functions in child namespaces are not included. Results are ordered by Function name then version. Local connections raise ``NotImplementedError``. Examples -------- List the identities available to use in Function-backed columns: ```python [(function.name, function.version) for function in db.list_functions()] ``` Returns a lazy iterator. ``page_limit`` limits each request, not the total; ``page_token`` resumes from a saved token. Requests and errors occur during iteration. See [pagination state][lancedb.listing.AsyncListing]. rr~rgr^ryrs rlist_functionszDBConnection.list_functionss2" T  rctd)aDrop a Function name and the object it was bound to. The requested version must exist in the currently named object. Returns True when the name was removed and False when it was absent. The object's content is deleted with it, which may finish after this returns; use :meth:`drop_function_async` to wait for that. Local connections raise NotImplementedError. rr~rs r drop_functionzDBConnection.drop_function" T  rctd)aDrop a Function name and return its cleanup job. The name is unbound before this returns; the object's content may still be being deleted. Call :meth:`Job.wait` to wait for that to finish. When the server deletes inline, or when nothing was bound, the returned job is already finished and has no id. Local connections raise NotImplementedError. rr~rs rdrop_function_asyncz DBConnection.drop_function_asyncrrctd)aBCreate a named Secret in this database. Fails if the name is taken, so a create never silently becomes a rotation. Nothing reads the value back: it is bound to a Function by name and resolved by the service when that Function runs. Local connections raise ``NotImplementedError``. >> import lancedb >>> db = lancedb.connect("db://my_database") # doctest: +SKIP >>> view = db.create_view( ... "adults", "SELECT name FROM people WHERE age >= 18" ... ) # doctest: +SKIP >>> view.schema # doctest: +SKIP name: string :View operations are not supported for this connection typer~rgrZr[r^s r create_viewzDBConnection.create_viewHs*" H  rctd)a%What this database records about a view: its defining query and the schema that query resolved to. The schema is the one recorded at creation; a source altered since then shows up when the view is read. Local connections raise ``NotImplementedError``. rr~rs r describe_viewzDBConnection.describe_viewa" H  rctd)aDrop a view and wait for its definition to be deleted. The tables it reads are untouched: a view holds no rows of its own. Use :meth:`drop_view_async` to get the cleanup job instead of waiting on it. Local connections raise ``NotImplementedError``. rr~rs r drop_viewzDBConnection.drop_viewos" H  rctd)abStart dropping a view and return the job deleting its definition. The name is free before this returns. Call :meth:`Job.wait` to wait for the definition dataset to be deleted. When nothing was bound to the name, the returned job is already finished and has no id. Local connections raise ``NotImplementedError``. rr~rs rdrop_view_asynczDBConnection.drop_view_async|rrctd)aThe names of the views in one namespace. Names only; a definition comes from [describe_view][lancedb.db.DBConnection.describe_view]. Local connections raise ``NotImplementedError``. Returns a lazy iterator. ``page_limit`` limits each request, not the total; ``page_token`` resumes from a saved token. Requests and errors occur during iteration. See [pagination state][lancedb.listing.AsyncListing]. rr~rs r list_viewszDBConnection.list_viewss"" H  rctd)aOpen a server-side job by id, returning a handle with its record already populated. The returned [Job][lancedb.job.Job] answers for its own state, specification, result, failure and event history, so there is no separate connection-level call for any of them. Raises `JobNotFoundError` when the server has no such job, the way `open_table` does for a missing table. z2open_job is not supported for this connection typer~rgjob_ids ropen_jobzDBConnection.open_jobs""VWWrctd).List server-side jobs across the database's tables. Returns a lazy iterator. ``page_limit`` limits each request, not the total; ``page_token`` resumes from a saved token. Requests and errors occur during iteration. See [pagination state][lancedb.listing.AsyncListing]. z3list_jobs is not supported for this connection typer~rs r list_jobszDBConnection.list_jobss""WXXrctd)Request cancellation of a server-side job by id. Returns True if the server accepted the cancellation, False if no such job exists. Cancelling an already-terminal job is a no-op success. z4cancel_job is not supported for this connection typer~r"s r cancel_jobzDBConnection.cancel_job" B  rctd)Pause a server-side job by id. The job's workers drain and it stays parked until resumed. Returns "pausing", "already_paused", or "committing" -- a job finalizing its results cannot be parked; retry shortly. z3pause_job is not supported for this connection typer~r"s r pause_jobzDBConnection.pause_jobs""WXXrctd)zResume a paused server-side job by id. Its workers pick their work back up from checkpoints. Returns "resumed", "still_pausing" -- the pause's worker drain is not confirmed yet; retry shortly -- or "not_paused". z4resume_job is not supported for this connection typer~r"s r resume_jobzDBConnection.resume_jobr+rr_ parameterscF|j|||jS)zExecute SQL and return a blocking Arrow reader. This submits through :meth:`execute_query_async` and waits until the initial result stream is readable. It does not wait for the full query to finish. r1execute_query_asyncreaderrgr[r_r2s r execute_queryzDBConnection.execute_querys.'' #9!(  &(  rctd)a[Start executing SQL and return its query handle. ``parameters`` binds values to the statement's ``$1`` / ``$name`` placeholders. They travel as Arrow rather than as SQL text, so a float keeps its exact value and type and a vector stays a compact fixed-size list. A list binds by position, a dict binds by name, and a one-row ``pyarrow.RecordBatch`` or ``pyarrow.Table`` binds both ways. A 1-D numpy or pyarrow array becomes a fixed-size list of its element type, the shape of a vector column: .. code-block:: python db.execute_query( "SELECT id FROM docs ORDER BY distance(vector, $1) LIMIT $2", parameters=[np.array([0.1, 0.2, 0.3], dtype=np.float32), 10], ) Parameters are supported in queries, not in DDL or DML. With or without parameters, the server chooses whether to stream rows on the initial call or return a polling continuation. The reader follows either path transparently. Dropping an unread handle or its reader stops a directly streamed query; deferred execution requires explicit cancellation. Open ``reader()`` directly: a streamed query needs its reader to make progress and reports ``running`` until the stream ends. Local connections do not support SQL. -SQL is not supported for this connection typer~r7s rr5z DBConnection.execute_query_asyncsD""QRRrctd)z;Describe a submitted SQL query by its connection-scoped id.r:r~rgquery_ids rdescribe_queryzDBConnection.describe_query s!"QRRr)returnrcr?Noner?boolNNNr^Optional[List[str]]ry Optional[str]rz Optional[int]r?r"NNr^ List[str]rrGrOptional[Dict[str, str]]r?r+r^rKrrGrrGr?r,r^rKr?r-)rrKr?rC)rrKr?rCr^rFryrGrzrHr?r#ryrGrzrHr^rFr? Iterable[str]NNcreateFerrorN)rZstrrOptional[DATA]r]&Optional[Union[pa.Schema, LanceModel]]rrVrrCrrVrfloatr'Optional[List[EmbeddingFunctionConfig]]r^rFrrLrrGrOptional[bool]r?rH)rZrVr?rG)rZrVr^rFrrLrrHrrGrrHr?rHrZrVrr?rr@rrGrzrHrrCrr[rOptional[float]r?r>rZrVrr?rr@rrGrzrHrrCrr[rr]r? Job[None]rZrVr?r>ryrGrrHr? Listing[str]rerZrVr^rFr?rArZrVr^rFr?r_)rZrVr^rFrZrVr^rFr?r6rrVrrVrrFrrFr^rFr?rV)r?zGenerator[str, None, None])r?int)rZrVr?rCr?r*)rr4r Optional[Sequence[EnvVarSecret]]r^rFr?r3rr4rrkr^rFr?zJob[FunctionVersion]rZrVrrVr^rFr?r3r^rFryrGrrHr?zListing[FunctionVersion]rZrVrrVr^rFr?rCrZrVrrVr^rFr?zTuple[bool, Job]rZrVr rVr^rFr?rAr^rFryrGrrHr?rbrZrVr^rFr?rCrZrVr[rVr^rFr?rMrZrVr^rFr?rMrZrVr^rFr?z 'Job[None]'r#rVr?r6ryrGrrHr?zListing[JobInfo]r#rVr?rCr#rVr?rV)r[rVr_rFr2Optional[QueryParameters]r?zpa.RecordBatchReader)r[rVr_rFr2r{r?SqlQueryr=zUnion[UUID, str]r?r:)>rrr__doc__rhrorrsrlr{rrrrrrrrrrrrrrrrrrrrrpropertyrrrrrrrrrrrrr r rrrrrrrr r$r'r*r.r0r8r5r>rrrrcrcs     $/3$(# I+I"I I  I>#/3  !  -  !  <#"&  !      6 ' " & , 2/3$(#  + "     :%)# /3  !  ,     6 $9=%GKq /348.237q q q 7 q  q  q q q Eq ,q 2q ,q #1q  q q f%/348*. $!%4 4 , 4 2 4 ( 4 4 4  4 v!##"/39=5 5 '5  5  5 5 5 -5 (75  5 x!##"/39=  '       - (7   0 .2t  *  ?L    @D    )<    @D    )<     $@D  )<  3726    0  0  <  &7/ ( Y"59.2 *!*2 * , *  *`59.2  ! 2  ,    ,/3      ,    /3$($(  , "  "  "  D/3     ,    0/3     ,    (OS    #  8K    OS    #  8K    "/3$($(  , "  "    *CG    ,?    CG    ,?    OS  # 8K  4CG    ,?    CG    ,?    CG    ,?    "/3$($(  , "  "    * X.2t Y* Y?L Y  Y  Y  7;04 !4  .   .7;04 "S"S!4 "S . "S  "SHSrrcceZdZdZddddddd dFdZedGdZedHdZedIdZe dJd Z dId Z e dKd Z e dLd Ze dId ZdMdZedNdZe dO dPdZe dQ dRdZe dQ dSdZe dTdZe dO dUdZe dQdd dVdZe dWddddd dXdZe dddddd dYdZe ddddddd dZdZe ddddddd d[dZe d\dZe ddd d]d Ze d^ d_d!Ze d^ d`d"Zdddd#d$ dad%Z e db dcd&Z!e d^ ddd'Z"e d^ded(Z#e dQ dfd)Z$e dgd*Z%e ddd+ dhd,Z&e dd did-Z'e dddd. djd/Z(e dd dkd0Z)e dd dld1Z*e dd dmd2Z+e dd dmd3Z,e dddd. dnd4Z-e dd d_d5Z.e dd dod6Z/e dd dpd7Z0e dd dqd8Z1e dd d_d9Z2e dd drd:Z3e dddd. dnd;Z4e ddd dsd<Z5e dtd=Z6e dud>Z7e dud?Z8e dvd@Z9e:jvdAdBe>> import lancedb >>> db = lancedb.connect("./.lancedb") >>> db.create_table("my_table", data=[{"vector": [1.1, 1.2], "b": 2}, ... {"vector": [0.5, 1.3], "b": 4}]) LanceTable(name='my_table', ...) >>> db.create_table("another_table", data=[{"vector": [0.4, 0.4], "b": 6}]) LanceTable(name='another_table', ...) >>> sorted(db.table_names()) ['another_table', 'my_table'] >>> len(db) 2 >>> db["my_table"] LanceTable(name='my_table', ...) >>> "my_table" in db True >>> db.drop_table("my_table") >>> db.drop_table("another_table") NF)read_consistency_intervalrsessionmanifest_enablednamespace_client_properties_innerc |_|_|_|_|||_||_d|_ytts t}ttxsdk(} | rttrnjdrddnjdrddtjdk(r#tdk\rdd k(r d d k(rd dtjj!tj#d d ||j% nd  fd} t't)j*| |_||_d|_y)Nfilezfile://zfile:/win32rr/:r1T)parentsrc \Kttddddd d{S7wre)lancedb_connectr')rrread_consistency_interval_secsrrrsr do_connectz.LanceDBConnection.__init__..do_connectnsD(S!. +    s ",*,)r_manifest_enabled_namespace_client_properties_session_conn_read_consistency_interval_cached_namespace_client isinstancerrJrV startswithsysplatformlen expanduserabsolutemkdir total_secondsAsyncConnectionr)run) rgrrrrrrrschemeis_localrrs ` ```` @r__init__zLanceDBConnection.__init__:si /!1,G)   DJ/HD +,0D ) #t$#C(Fc4(>),ab'C^^H-ab'C<<7*3x1}Q33q6S=!!"g3i.."++-C IOOD4O 8 $ 0-F-T-T-V *-1 *  (%TXXjl%;< +D'BF%rc|jSre)rrfs rrz+LanceDBConnection.read_consistency_intervals...rc|jS)zReturn the session supplied when this connection was opened. None when the caller did not pass a session, including connections reconstructed with :meth:`from_inner`. )rrfs rrzLanceDBConnection.sessions}}rc.|jjSre)rrrfs rrzLanceDBConnection.uriszz~~rc|d||S)N)rrr)clsinnerrs r from_innerzLanceDBConnection.from_inners  &?  rcb|jjd|jjdS)Nz(uri=)) __class__rrrrfs r__repr__zLanceDBConnection.__repr__s)..))*% /ACCrc6|jjSre)rrsrfs rrszLanceDBConnection.is_openszz!!##rc8|jjyre)rrlrfs rrlzLanceDBConnection.closes rc ddl}|j}|jd|j|j|j |j |r|jdSddS)Nrlocal)connection_typerrrr!read_consistency_interval_seconds)jsonrdumpsrrrrr)rgrrcis rrzLanceDBConnection.serializesm,,zz#*xx#'#7#7$($:$:/3/P/P+.C%%'   59   rcKtt|jd{}|j||d{S7#7w)N) start_afterrz)rrrr)rgrrzconns r_async_get_table_namesz(LanceDBConnection._async_get_table_namess>_TXX%>>?%%+U%KKK ?Ks AAAAAAc.|jjSre)rrrfs rrzLanceDBConnection._innerszz   rcX|g}t|jj|||S)aList immediate child namespace names in the given namespace. Parameters ---------- namespace_path: List[str], optional The parent namespace to list namespaces in. None or empty list represents root namespace. page_token: str, optional Token for pagination. Use the token from a previous response to get the next page of results. limit: int, optional The maximum number of results to return. Returns ------- NamespaceListing Response containing namespace names and optional page_token for pagination. r^ryrz)r"rr{rxs rr{z!LanceDBConnection.list_namespacess:2  !N JJ & &-*E '   rcdtj|jj|||S)N)r^rr)r)rrrrs rrz"LanceDBConnection.create_namespaces5xx JJ ' '-% (   rc tj|jj|||S#t$r(}dt |vrt t ||d}~wwxYw)N)r^rrzNamespace not empty)r)rrr RuntimeErrorrVr/)rgr^rres rrz LanceDBConnection.drop_namespacesj 88 ))#1%*  $A.,SV4!;  s03 A$#AA$c`tj|jj|SNr)r)rrrrs rrz$LanceDBConnection.describe_namespaces%xx 55^5TUUrcX|g}t|jj|||S)rr)r#rrrxs rrzLanceDBConnection.list_tabless:4  !N JJ " "-*E #   rrcddl}|jdtd|g}tj|j j |||S)ayGet the names of all tables in the database. The names are sorted. .. deprecated:: Use :meth:`list_tables` instead, which provides proper pagination support. Parameters ---------- namespace_path: List[str], optional The namespace to list tables in. page_token: str, optional The token to use for pagination. limit: int, optional The maximum number of tables to return. None returns all tables; zero returns an empty list. Returns ------- Iterator of str. A list of table names. rN6table_names() is deprecated, use list_tables() insteadr stacklevelr^rrz)warningswarnDeprecationWarningr)rrr)rgryrzr^rs rrzLanceDBConnection.table_names6s]8  D    !Nxx JJ " "-:U #   rrc h| g} t|tj|||||||||| | | |  } | S)zCreate a table in the database. Parameters ---------- namespace_path: List[str], optional The namespace to create the table in. See --- DBConnection.create_table ) rrrrrr^rrr)rKrGrS)rgrZrr]rrrrrr^rrrtbls rrzLanceDBConnection.create_tableasU8  !ND!    )! 3)+!5%=  rrc|g}|ddl}|jdtd tj|||||}||jj||}|S||j||S#t t f$rF} |r>dt| vs dt| vr$||gz} td d j| | d} ~ wwxYw) aOpen a table in the database. Parameters ---------- name: str The name of the table. namespace_path: List[str], optional The namespace to open the table from. When non-empty, the table is resolved through the directory namespace client. branch: str, optional If provided, open a handle scoped to this branch instead of the default branch. Reads and writes operate in the branch's context. version: int, optional If provided, open the table pinned to this version, producing a read-only handle. Composes with ``branch``: when both are given, opens that branch at the version; otherwise opens ``main`` at the version. Call ``checkout_latest`` to return to a writable state. Returns ------- A LanceTable object representing the table. Nrzindex_cache_size is deprecated. Use session-level cache configuration instead. Create a Session with custom cache sizes and pass it to lancedb.connect().rr)r^rrzTable not foundz was not foundzTable not found: $) rrrrGopenr ValueErrorrVr0joinbranchescheckout) rgrZr^rrrrrrrrs rrzLanceDBConnection.open_tablesB  !N  '  MM4#   //- /!1 C"  ,,''8C  LL ! j) !SV+#a&/H)TF2('(:';<  sA33CACCrc tj|jj||||||||t |j |S)aDefine a materialized view named ``name`` over the table ``source``. Local creation and refresh require a source build with the ``experimental-functions`` Cargo feature. Published packages leave it disabled; remote Cloud/Enterprise operations remain available. See [DBConnection.create_materialized_view][lancedb.DBConnection.create_materialized_view]. Examples -------- >>> import lancedb >>> db = lancedb.connect("./.lancedb") >>> data = [{"name": "ada", "age": 36}, {"name": "kid", "age": 7}] >>> table = db.create_table("people", data) >>> view = db.create_materialized_view( # doctest: +SKIP ... "adults", ... "people", ... select=["name", ("shout", "upper(name)")], ... where="age >= 18", ... ) >>> view.table.count_rows() # doctest: +SKIP 1 r)r)rrrr>rrs rrz*LanceDBConnection.create_materialized_viewsVH  JJ / /)%9.K 0    566rc tj|jj||||||||} t | S)Nr)r)rrrr6) rgrZrrrrzrrrjobs rrz0LanceDBConnection.create_materialized_view_async sLhh JJ 5 5)%9.K 6   3xrcRt|j|}|j|S)z*Open the materialized view named ``name``.)r>rrrgrZviews rrz(LanceDBConnection.open_materialized_view%s#  56  rrcNt|jj||S)a0The names of the materialized views in this database. Returns a lazy iterator. ``page_limit`` limits each request, not the total; ``page_token`` resumes from a saved token. Requests and errors occur during iteration. See [pagination state][lancedb.listing.AsyncListing]. r)r!rrrs rrz)LanceDBConnection.list_materialized_views,s- JJ . .%* /   rcl|g}tj|jj||yr)r)rrrrs rrz(LanceDBConnection.drop_materialized_view<s/  !N 2242WXrc|g}tj|jj||}t |Sr)r)rrrr6rgrZr^rs rrz.LanceDBConnection.drop_materialized_view_asyncDs?  !Nhh JJ 3 3D 3 X 3xrTtarget_namespace_pathsource_version source_tag is_shallowc |g}tj|jj||||||t j |||S)awClone 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. Parameters ---------- target_table_name: str The name of the target table to create. source_uri: str The URI of the source table to clone from. target_namespace_path: List[str], optional The namespace for the target table. None or empty list represents root namespace. source_version: int, optional The version of the source table to clone. source_tag: str, optional The tag of the source table to clone. is_shallow: bool, default True Whether to perform a shallow clone (True) or deep clone (False). Currently only shallow clone is supported. Returns ------- A LanceTable object representing the cloned table. rr)r)rr clone_tablerGr)rgtarget_table_name source_urirrrrs rrzLanceDBConnection.clone_tableOsbL ! ($& !  JJ " "!&;-%% #    0  rcn|g}tj|jj|||y)aGDrop a table from the database. Parameters ---------- name: str The name of the table. namespace_path: List[str], optional The namespace to drop the table from. ignore_missing: bool, default False If True, ignore if the table does not exist. Nr^ignore_missing)r)rrr)rgrZr^rs rrzLanceDBConnection.drop_tables9$  !N  JJ ! !^N "  rc|g}tj|jj||}t t |t r|St |S)zStart dropping a table and return its cleanup job. The table may become unavailable before its data files are removed. Call :meth:`Job.wait` to wait for cleanup to finish. r)r)rrrr6rr5rs rrz"LanceDBConnection.drop_table_asyncsQ  !Nhhtzz2242WX*S(33GG#GGrcj|g}tj|jj|yrr)rrrrs rrz!LanceDBConnection.drop_all_tabless+  !N ++>+JKrcx|g}|g}tj|jj||||y)aRename a table in the database. Parameters ---------- cur_name: str The current name of the table. new_name: str The new name of the table. cur_namespace_path: List[str], optional The namespace of the current table. new_namespace_path: List[str], optional The namespace to move the table to. Nrr)r)rrrrs rrzLanceDBConnection.rename_tablesK*  %!#   %!#   JJ # ##5#5 $  rcpttj|jj |S)mOpen a server-side job by id. See [DBConnection.open_job][lancedb.db.DBConnection.open_job]. )r6r)rrr$r"s rr$zLanceDBConnection.open_jobs' 488DJJ//7899rrcztj|jj|||}t |S)Nr)r)rrrr6)rgrrr^rs rrz'LanceDBConnection.create_function_asyncs;hh JJ , ,GN -   3xrcdtj|jj|||SN)rr^)r)rrrrs rrzLanceDBConnection.get_functions3xx JJ # #gn $   rrcPt|jj|||S)a List functions. Returns a lazy iterator. ``page_limit`` limits each request, not the total; ``page_token`` resumes from a saved token. Requests and errors occur during iteration. See [pagination state][lancedb.listing.AsyncListing]. r)r!rrrs rrz LanceDBConnection.list_functionss1 JJ % %-%% &   rcdtj|jj|||Sr)r)rrrrs rrzLanceDBConnection.drop_functions3xx JJ $ $gn %   rctj|jj|||\}}|t |fSr)r)rrrr6rgrZrr^droppedrs rrz%LanceDBConnection.drop_function_asyncsExx JJ * *gn +   C  rcftj|jj|||yr)r)rrr rs rr zLanceDBConnection.create_secret.s& ))$n)UVrcftj|jj|||yr)r)rrr rs rr zLanceDBConnection.alter_secret4s& ((u^(TUrcPt|jj|||S)aList secrets. Returns a lazy iterator. ``page_limit`` limits each request, not the total; ``page_token`` resumes from a saved token. Requests and errors occur during iteration. See [pagination state][lancedb.listing.AsyncListing]. r)r!rrrs rrzLanceDBConnection.list_secrets:s1 JJ # #-%% $   rcdtj|jj||yr)r)rrrrs rrzLanceDBConnection.drop_secretPs$ ''^'LMrcbtj|jj||Sr)r)rrrrs rrz!LanceDBConnection.describe_secretVs'xx 2242WXXrcdtj|jj|||Sr)r)rrrrs rrzLanceDBConnection.create_view\s.xx JJ " "4~ " N  rcbtj|jj||Sr)r)rrrrs rrzLanceDBConnection.describe_viewds'xx 00n0UVVrcdtj|jj||yr)r)rrrrs rrzLanceDBConnection.drop_viewjs$ %%d>%JKrctttj|jj ||Sr)r6r)rrrrs rrz!LanceDBConnection.drop_view_asyncps1 HHTZZ//^/T U  rcPt|jj|||S)aList views. Returns a lazy iterator. ``page_limit`` limits each request, not the total; ``page_token`` resumes from a saved token. Requests and errors occur during iteration. See [pagination state][lancedb.listing.AsyncListing]. r)r!rr rs rr zLanceDBConnection.list_viewsxs1 JJ ! !-%% "   rcNt|jj||Sr&r)r!rr'rs rr'zLanceDBConnection.list_jobss( JJ J: N  rc^tj|jj|S)r))r)rrr*r"s rr*zLanceDBConnection.cancel_jobs"xx --f566rc^tj|jj|S)zfPause a server-side job by id. Returns "pausing", "already_paused", or "committing". )r)rrr.r"s rr.zLanceDBConnection.pause_jobs" xx ,,V455rc^tj|jj|S)zmResume a paused server-side job by id. Returns "resumed", "still_pausing", or "not_paused". )r)rrr0r"s rr0zLanceDBConnection.resume_jobs" xx --f566rc|j2tj|jj |_|jS)aYGet the equivalent namespace client for this connection. Returns a DirectoryNamespace pointing to the same root with the same storage options. The result is cached for the lifetime of this connection. Returns ------- LanceNamespace The namespace client for this connection. )rr)rrrrfs rrz"LanceDBConnection.namespace_clients:  ( ( 0,0HHTZZ5P5P5R,SD ),,,r0.15.10.17Use drop_all_tables() instead deprecated_in removed_incurrent_versiondetailsc^tj|jjyrerrfs rrzLanceDBConnection.drop_databases ++-.r)rrSrOptional[timedelta]rrLrOptional[Session]rrCrrLrzOptional[LanceDbConnection]r?r)r?rrh)rLanceDbConnectionrrrBr@)rrGrzri)r?rrDrErIrJrMrNrOrPrR)rZrVrrWr]rXrrVrrCrrVrrYrrZr^rFrrLrrGrr[r?rG)rZrVr^rFrrLrrHrrGrrHr?rGr\r^r`rarercrd)rrVrrVrrFrrHrrGrrCr?rG)NFrZrVr^rFrrCrergrfrwrlrmrnrorprqrrrsrtrurvrxryrzrj)>rrrr~rrrrr classmethodrrrrsrlrrrr{rrrrrrrrrrrrrrrrrrr$rrrrrr r rrrrrrrr r'r*r.r0r deprecation deprecatedr2rrrrrrs %V:>48%)!&@D.2LG LG$7 LG 2 LG # LGLG&>LG,LG\//     $7    D$$  "L!!/3$(#  + "      @#/3  !    -  !    #"& !   &V'V "VV /3$(#  + "      B%)#( /3 ( !( ( , (  ( ( T $9=%GK./348.237...7 .  .  ...E.,.2.,.#1. ..` /348*. $!%CC, C 2 C ( CCC CCJ !##"/39=/7/7'/7  /7  /7/7/7-/7(7/7 /7/7b !##"/39='    -(7 4 -1t  *  ?L      ?CYY)<Y YY?C)< 6:(,$(6 6 6 3 6 & 6 "6 6  6 p/3$   ,    2?C H H)< H  H HLL  3726    0  0   B::  59.2 ! 2  ,     /3      ,      /3$($(  , "  "  "   * /3      ,       /3 ! ! ! , !  ! !NRWW #W8KW WW NRVV #V8KV VV /3$($(  , "  "     *BFNN,?N NN BFYY,?Y YY NR  # 8K   BFWW,?W WW BFLL,?L LL BF  ,?   /3$($(  , "  "     *-1t  *  ?L      776677-- [#/  / /rrc PeZdZdZdIdZdZdZdZdZdZ e dJdZ dKd Z dL dMd Z dN dOd Z dN dPd Z dQdZ dL dRdZd d d d dSdZ dTd d d d d dUdZd d d d d d d d d dVdZ dWdZd d d dd d d dXdZd d d dd d d dYdZdZdZd d d d[dZd d d\dZd d d]d Zd d d d!d" d^d#Z dN d_d$Zd dd% d`d&Zd d dad'Zdbdcd(Z ddd)Z!d d d* ded+Z"d d dfd,Z#d d d d- dgd.Z$d d dhd/Z%d d did0Z&d d djd1Z'd d djd2Z(d d d d- dkd3Z)d d d\d4Z*d d dld5Z+d d dmd6Z,d d dnd7Z-d d d\d8Z.d d d]d9Z/d d d d- dkd:Z0d d d dod;Z1dpd<Z2dqd=Z3dqd>Z4d d d? drd@Z5d d d? dsdAZ6dtdBZ7dudCZ8e9jtdDdEe;dFGdHZ>> import lancedb >>> async def doctest_example(): ... with await lancedb.connect_async("/tmp/my_dataset") as conn: ... # do something with the connection ... pass ... # conn is closed here c||_yre)r)rg connections rrzAsyncConnection.__init__s   rc6|jjSre)rrrfs rrzAsyncConnection.__repr__s{{##%%rc|Srerrfs rrhzAsyncConnection.__enter__rirc$|jyrerkrms rrozAsyncConnection.__exit__rprc6|jjS)rr)rrsrfs rrszAsyncConnection.is_opens{{""$$rc8|jjy)zClose 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.N)rrlrfs rrlzAsyncConnection.close s rc.|jjSre)rrrfs rrzAsyncConnection.uri s{{rcpK|jjd{}| t|Sy7w)N)seconds)rget_read_consistency_intervalr)rg interval_secss rr,z-AsyncConnection.get_read_consistency_interval s5"kkGGII  $]3 3 Js 646Nc|g}t||jj|||}|dk(r tddSt||S)abList immediate child namespace names in the given namespace. Parameters ---------- namespace_path: List[str], optional The parent namespace to list namespaces in. None or empty list represents root namespace. page_token: str, optional The token to use for pagination. If not present, start from the beginning. limit: int, optional The maximum number of results to return. Returns ------- AsyncNamespaceListing Response containing namespace names and optional pagination token NrrTrv)r$rr{rrgr^ryrzrs rr{zAsyncConnection.list_namespaces sZ.  !NE" ++)j,  A:(T: :$UJ77rcK|jj|t||d{}tdi|S7w)aCreate a new namespace. Parameters ---------- namespace_path: List[str] The namespace identifier to create. mode: str, optional Creation mode - "create", "exist_ok", or "overwrite". Case insensitive. properties: Dict[str, str], optional Properties to associate with the namespace Returns ------- CreateNamespaceResponse Response containing namespace properties )rrNr)rrrVr+)rgr^rrresults rrz AsyncConnection.create_namespace6 sI,{{33 1$7!4   '000  s +?=?cK|jj|t|t|d{}t di|S7w)r)rrNr)rrrWrXr,)rgr^rrr1s rrzAsyncConnection.drop_namespaceS sN.{{11 /57A2   %.v..  s4AAAcjK|jj|d{}tdi|S7w)rNr)rrr-)rgr^r1s rrz"AsyncConnection.describe_namespaceq s3{{55nEE(2622Fs 313c|g}t||jj|||}|dk(r tddSt||S)aList tables in this database, one page at a time. Parameters ---------- namespace_path: List[str], optional The namespace to list tables in. None or empty list represents root namespace. page_token: str, optional Token for pagination. Use the token from a previous response to get the next page of results. limit: int, optional The maximum number of results to return, default 100. Zero returns an empty page without a continuation token. Returns ------- AsyncTableListing Response containing table names and optional page_token for pagination. NrrTrv)r$rrr r/s rrzAsyncConnection.list_tables sZ2  !NE" '')j(  A:$T6 6  33rrcKddl}|jdtd|g}|jj |||d{S7w)aNList all tables in this database, in sorted order .. deprecated:: Use :meth:`list_tables` instead, which provides proper pagination support. Parameters ---------- namespace_path: List[str], optional The namespace to list tables in. None or empty list represents root namespace. start_after: str, optional 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. limit: int, optional The maximum number of tables to return. None returns all tables; zero returns an empty list. Returns ------- Iterable of str rNrrrr)rrrrr)rgr^rrzrs rrzAsyncConnection.table_names s_>  D    !N[[,,){%-    sAA A A )r^rlocationrc  K| g} d} | %tj}|j| } |d}|d}tjt ||| ||d{\}}t ||d}|d}|dk(r|rd}|5|jj|||| || | d{}t|St||}|jj|||| || | d{}t|S77R7w)aCreate an [AsyncTable][lancedb.table.AsyncTable] in the database. Parameters ---------- name: str The name of the table. namespace_path: List[str], default [] The namespace to create the table in. Empty list represents root namespace. data: The data to initialize the table, *optional* User must provide at least one of `data` or `schema`. Acceptable types are: - list-of-dict - pandas.DataFrame - pyarrow.Table or pyarrow.RecordBatch schema: The schema of the table, *optional* Acceptable types are: - pyarrow.Schema - [LanceModel][lancedb.pydantic.LanceModel] mode: Literal["create", "overwrite", "exist_ok"]; default "create" The mode to use when creating the table. Can be "create", "overwrite", or "exist_ok". By default, if the table already exists, an exception is raised. If you want to overwrite the table, use mode="overwrite". To open an existing table without adding data, use mode="exist_ok". exist_ok: bool, default False If a table by the same name already exists, then raise an exception if exist_ok=False. If exist_ok=True, then open the existing table; it will not add the provided data but will validate against any schema that's specified. on_bad_vectors: str, default "error" How to handle vectors with incorrect sizes, NaNs, or null elements. One of "error", "drop", "fill", "null". fill_value: float The value to use when filling vectors. Only used if on_bad_vectors="fill". NaN or null elements and missing trailing elements are replaced with this value. Valid elements are preserved, and vectors longer than the expected dimension are truncated. storage_options: dict, optional Additional options for the storage backend. Options already set on the connection will be inherited by the table, but can be overridden here. See available options at To enable stable row IDs (row IDs remain stable after compaction, update, delete, and merges), set `new_table_enable_stable_row_ids` to `"true"` in storage_options when connecting to the database. Returns ------- AsyncTable A reference to the newly created table. !!! note The vector index won't be created by default. To create the index, call the `create_index` method on the table. Examples -------- Can create with list of tuples or dictionaries: >>> import lancedb >>> async def doctest_example(): ... db = await lancedb.connect_async("./.lancedb") ... data = [{"vector": [1.1, 1.2], "lat": 45.5, "long": -122.7}, ... {"vector": [0.2, 1.8], "lat": 40.1, "long": -74.1}] ... my_table = await db.create_table("my_table", data) ... print(await my_table.query().limit(5).to_arrow()) >>> import asyncio >>> asyncio.run(doctest_example()) pyarrow.Table vector: fixed_size_list[2] child 0, item: float lat: double long: double ---- vector: [[[1.1,1.2],[0.2,1.8]]] lat: [[45.5,40.1]] long: [[-122.7,-74.1]] You can also pass a pandas DataFrame: >>> import pandas as pd >>> data = pd.DataFrame({ ... "vector": [[1.1, 1.2], [0.2, 1.8]], ... "lat": [45.5, 40.1], ... "long": [-122.7, -74.1] ... }) >>> async def pandas_example(): ... db = await lancedb.connect_async("./.lancedb") ... my_table = await db.create_table("table2", data) ... print(await my_table.query().limit(5).to_arrow()) >>> asyncio.run(pandas_example()) pyarrow.Table vector: fixed_size_list[2] child 0, item: float lat: double long: double ---- vector: [[[1.1,1.2],[0.2,1.8]]] lat: [[45.5,40.1]] long: [[-122.7,-74.1]] Data is converted to Arrow before being written to disk. For maximum control over how data is saved, either provide the PyArrow schema to convert to or else provide a [PyArrow Table][pyarrow.Table] directly. >>> import pyarrow as pa >>> custom_schema = pa.schema([ ... pa.field("vector", pa.list_(pa.float32(), 2)), ... pa.field("lat", pa.float32()), ... pa.field("long", pa.float32()) ... ]) >>> async def with_schema(): ... db = await lancedb.connect_async("./.lancedb") ... my_table = await db.create_table("table3", data, schema = custom_schema) ... print(await my_table.query().limit(5).to_arrow()) >>> asyncio.run(with_schema()) pyarrow.Table vector: fixed_size_list[2] child 0, item: float lat: float long: float ---- vector: [[[1.1,1.2],[0.2,1.8]]] lat: [[45.5,40.1]] long: [[-122.7,-74.1]] It is also possible to create an table from `[Iterable[pa.RecordBatch]]`: >>> import pyarrow as pa >>> def make_batches(): ... for i in range(5): ... yield pa.RecordBatch.from_arrays( ... [ ... pa.array([[3.1, 4.1], [5.9, 26.5]], ... pa.list_(pa.float32(), 2)), ... pa.array(["foo", "bar"]), ... pa.array([10.0, 20.0]), ... ], ... ["vector", "item", "price"], ... ) >>> schema=pa.schema([ ... pa.field("vector", pa.list_(pa.float32(), 2)), ... pa.field("item", pa.utf8()), ... pa.field("price", pa.float32()), ... ]) >>> async def iterable_example(): ... db = await lancedb.connect_async("./.lancedb") ... await db.create_table("table4", make_batches(), schema=schema) >>> asyncio.run(iterable_example()) NrTrUFrSr)r^rr6r) r% get_instanceget_table_metadataasyncio to_threadrIr(rcreate_empty_tabler&rrF)rgrZrr]rrrrrr^rr6rmetadataregistry new_tables rrzAsyncConnection.create_table sXb  !N  *1==?H223FGH  !$N  J %.. !        f   H <D 8 D <"kk<<- /!!1=I*)$$"$/D"kk66- /!!17I)$$O $s8AC;C5A C;$C7%AC;%C9&C;7C;9C;)r^rrr6rmanaged_versioningrrc K|g}|jj|||||||d{} t| } |+|dk7r&| jj || d{} | S| | j | d{| S7Y7%7 w)a Open a Lance Table in the database. Parameters ---------- name: str The name of the table. namespace_path: List[str], optional The namespace to open the table from. None or empty list represents root namespace. storage_options: dict, optional Additional options for the storage backend. Options already set on the connection will be inherited by the table, but can be overridden here. See available options at index_cache_size: int, default 256 **Deprecated**: Use session-level cache configuration instead. Create a Session with custom cache sizes and pass it to lancedb.connect(). Set the size of the index cache, specified as a number of entries 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 location: str, optional The explicit location (URI) of the table. If provided, the table will be opened from this location instead of deriving it from the database URI and table name. managed_versioning: bool, optional Whether managed versioning is enabled for this table. If provided, avoids a redundant describe_table call when namespace_client is set. branch: str, optional If provided, open a handle scoped to this branch instead of the default branch. Reads and writes operate in the branch's context. version: int, optional If provided, open the table pinned to this version, producing a read-only handle. Composes with ``branch``: when both are given, opens that branch at the version; otherwise opens ``main`` at the version. Call ``checkout_latest`` to return to a writable state. Returns ------- A LanceTable object representing the table. N)r^rrr6rr@main)rrrFrr) rgrZr^rrr6rr@rrtablers rrzAsyncConnection.open_table sx  !Nkk,, )+--1-    &F"2 --fg>>C  ,,w' ' ' ! ? 's3*B B5B "B#B ?B B B  B cK|ifSwrer)rgrrrrzs r_materialized_view_sourcez)AsyncConnection._materialized_view_source srzsFrc K|j||||d{\}} |jj||ft||||||d| d{} t t | S7Q7w)aDefine a materialized view named ``name`` over the table ``source``. Local creation and refresh require a source build with the ``experimental-functions`` Cargo feature. Published packages leave it disabled; remote Cloud/Enterprise operations remain available. See [DBConnection.create_materialized_view][lancedb.DBConnection.create_materialized_view]. N projectionsfilterrzrrr)rErrrAr=rF rgrZrrrrzrrrnative_optionsrs rrz(AsyncConnection.create_materialized_view s((,'E'E FE5( " ;dkk::    )0%!5*G     %Z%677"   s!A0A,8A0A.A0.A0c K|j||||d{\}} |jj||ft||||||d| d{} t | S7H7w)aSubmit materialized-view creation and return its job. Wait for the returned job before opening or querying the view. Remote creation uses SQL; ``job_type`` is ``"query"`` and ``id`` identifies that query on this connection. NrG)rErrrAr5rJs rrz.AsyncConnection.create_materialized_view_async? s$(,'E'E FE5( " Adkk@@    )0%!5*G     "   s!A'A#8A'A%A'%A'cKt|j|d{}|jd{|S7"7w)rN)r=rrrs rrz&AsyncConnection.open_materialized_viewa s= %4??4+@%@Aoo &AsA?AAAArcNt|jj||S)rr)rrrrs rrz'AsyncConnection.list_materialized_viewsk s- KK / /%* 0   rrcbK|g}|jj||d{y7w)rNr)rrrs rrz&AsyncConnection.drop_materialized_view| s0  !Nkk00n0UUUs %/-/crK|g}t|jj||d{S7w)aStart dropping a materialized view and return its job. For remote connections, the job has type ``query`` and its ID identifies the SQL query. Await :meth:`AsyncJob.wait` for catalog removal; physical cleanup continues in the background. Nr)r5rrrs rrz,AsyncConnection.drop_materialized_view_async sF  !N++::^;     *75 7Trc~K|g}|jj||||||d{}t|S7w)axClone 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. Parameters ---------- target_table_name: str The name of the target table to create. source_uri: str The URI of the source table to clone from. target_namespace_path: List[str], optional The namespace for the target table. None or empty list represents root namespace. source_version: int, optional The version of the source table to clone. source_tag: str, optional The tag of the source table to clone. is_shallow: bool, default True Whether to perform a shallow clone (True) or deep clone (False). Currently only shallow clone is supported. Returns ------- An AsyncTable object representing the cloned table. Nr)rrrF)rgrrrrrrrCs rrzAsyncConnection.clone_table sWL ! ($& !kk--  "7)!! .  %   s )=;=cnK|g}|g}|jj||||d{y7w)rNr)rrrs rrzAsyncConnection.rename_table sM,  %!#   %!# kk&&  11 '   s +535rcK|g} |jj||d{y7#t$r!}|s|d|dt|vr|Yd}~yd}~wwxYww)a{Drop a table from the database. Parameters ---------- name: str The name of the table. namespace_path: List[str], default [] The namespace to drop the table from. Empty list represents root namespace. ignore_missing: bool, default False If True, ignore if the table does not exist. NrzTable 'z' was not found)rrrrV)rgrZr^rrs rrzAsyncConnection.drop_table sk&  !N ++((n(M M M !o.c!f<= s6A 0.0A0 AAAAAcrK|g}t|jj||d{S7w)zStart dropping a table and return its cleanup job. The table may become unavailable before its data files are removed. Await :meth:`AsyncJob.wait` to wait for cleanup to finish. Nr)r5rrrs rrz AsyncConnection.drop_table_async s=  !N++..tN.S S  SrQc`K|g}|jj|d{y7w)zDrop all tables from the database. Parameters ---------- namespace_path: List[str], optional The namespace to drop all tables from. None or empty list represents root namespace. Nrrrrs rrzAsyncConnection.drop_all_tables s.  !Nkk)))HHHs $.,.cfKt|jj|d{S7w)rN)r5rr$r"s rr$zAsyncConnection.open_job- s(dkk226::;;:s $1/ 1rcKt|ts td|j|}|jj |j |d{}t|tjS7w)a1Submit a scalar Python UDF for building and registration. The server-side job builds the OCI image, then registers the completed artifact. Waiting on the job returns the immutable Function version. ``secrets`` is a sequence of [EnvVarSecret][lancedb.secrets.EnvVarSecret], each naming a Secret and the environment variable its value arrives in. ``namespace_path`` is the namespace the Function is registered in; None or an empty list is the root. Local connections raise ``NotImplementedError``. z0create_function_async requires a @udf definitionN) rr4 TypeError bind_secretsrrto_canonical_jsonr7r3 from_json)rgrrr^requestrs rrz%AsyncConnection.create_function_async3 so"*m4NO O))'2kk77  % % '  %!:!:;; sAA=A;A=c~Ktj|jj|||d{S7w)rN)r3r]rrrs rrzAsyncConnection.get_functionL s7((++**4.I I  I 0=; =rcnt|jj|||tjS)aList every published immutable Function version in a namespace. Functions in child namespaces are not included. Results are ordered by Function name then version. Local connections raise ``NotImplementedError``. Returns a lazy iterator. ``page_limit`` limits each request, not the total; ``page_token`` resumes from a saved token. Requests and errors occur during iteration. See [pagination state][lancedb.listing.AsyncListing]. r)rrrr3r]rs rrzAsyncConnection.list_functionsX s<" KK & &-%% '   % %   rcXK|jj|||d{S7w)z4Drop a Function name and the object it was bound to.N)rrrs rrzAsyncConnection.drop_functionr s'[[..tWnMMMMs !*(*cxK|jj|||d{\}}|t|fS7w)zDrop a Function name and return its cleanup job. The name is unbound before this returns; the object's content may still be being deleted. Await :meth:`AsyncJob.wait` to wait for that to finish. N)rrr5rs rrz#AsyncConnection.drop_function_async| sB"[[<< '>   %% s !:8:c K|jjt||tt |d{y7w)zCreate a named Secret in this database. Fails if the name is taken, so a create never silently becomes a rotation. Nothing reads the value back. N)rr rElistrDrs rr zAsyncConnection.create_secret s=kk''  &  (8 9    Ac Kt|jj|t|xsgd{S7w)z:What this database records about a view: query and schema.N)rarrrers rrzAsyncConnection.describe_view s9!++++D$~7K2LM M  Ms 2?= ?crK|jj|t|xsgd{y7w)zDrop a view and wait for its definition to be deleted. The tables it reads are untouched. Use :meth:`drop_view_async` to get the cleanup job instead of waiting on it. N)rrrers rrzAsyncConnection.drop_view s,kk##D$~/C*DEEEs -757crK|g}t|jj||d{S7w)zStart dropping a view and return the job deleting its definition. The name is free before this returns. Await :meth:`AsyncJob.wait` before assuming the definition dataset is gone. Nr)r5rrrs rrzAsyncConnection.drop_view_async s=  !N++--d>-R R  RrQcPt|jj|||S)a#The names of the views in one namespace. Returns a lazy iterator. ``page_limit`` limits each request, not the total; ``page_token`` resumes from a saved token. Requests and errors occur during iteration. See [pagination state][lancedb.listing.AsyncListing]. r)rrr rs rr zAsyncConnection.list_views s1 KK " "-%% #   rcNt|jj||Sr )rrr'rs rr'zAsyncConnection.list_jobs s( KK ! !ZJ ! O  rcTK|jj|d{S7w)r)N)rr*r"s rr*zAsyncConnection.cancel_job& s#[[++F3333 (&(cTK|jj|d{S7w)r-N)rr.r"s rr.zAsyncConnection.pause_job/ s#[[**62222rtcTK|jj|d{S7w)zResume a paused server-side job by id. Its workers pick their work back up from checkpoints. Returns "resumed", "still_pausing" -- retry shortly -- or "not_paused". N)rr0r"s rr0zAsyncConnection.resume_job8 s# [[++F3333rtr1czK|j|||d{}|jd{S77w)zExecute SQL and return an asynchronous Arrow reader. This submits through :meth:`execute_query_async` and waits until the initial result stream is readable. It does not wait for the full query to finish. r1Nr4)rgr[r_r2 submitteds rr8zAsyncConnection.execute_query@ sJ22 #9!3  %%'''  (s;7;9;;c ~Kt|jj||t|d{S7w)aStart executing SQL and return its query handle. The database from ``connect_async`` is used for unqualified database references. The namespace defaults to ``["public"]``. ``parameters`` binds values to ``$1`` / ``$name`` placeholders; see [DBConnection.execute_query_async][lancedb.db.DBConnection.execute_query_async]. Local connections raise ``NotImplementedError``. r1N) AsyncSqlQueryrr5r<r7s rr5z#AsyncConnection.execute_query_asyncT sD++11'=-j92    r`cKt|tr t|}|jj |d{S7w)zDescribe a submitted SQL query by its UUID or string ID. For a handle with ``job_type == "query"``, pass its ``id`` on the connection that submitted it. Registry job IDs are not query IDs. N)rrVrrr>r<s rr>zAsyncConnection.describe_queryk s6 h $H~H[[//9999s:AAAcvK|jjd{}t|d|dS7w)rNimplr)rnamespace_client_confignamespace_connect)rgconfigs rrz AsyncConnection.namespace_clientu s8 {{::<<  1EFF=s 979rrrrcTK|jjd{y7w)rNrWrfs rrzAsyncConnection.drop_database skk))+++s (&()r#rrhrrD)r^rFryrGrzrHr?rrIrJrMrN)r^rFryrGrzrHr?r )r^rFrrGrzrHr?rQ)NNNNNNN)rZrVrrWr]rXrz(Optional[Literal['create', 'overwrite']]rr[rrGrr]rrLr^rFrrZr6rGr Optional[Any]r?rF)rZrVr^rFrrLrrHr6rGrrr@r[rrGrrHr?rF) rr?rr@rrGrzrHr?zTuple[str, Dict[str, str]])rZrVrr?rr@rrGrzrHrrCrr[rr]r?r=)rZrVrr?rr@rrGrzrHrrCrr[rr]r?AsyncJob[None])rZrVr?r=)ryrGrrHr?AsyncListing[str]rc)rZrVr^rFr?r)rrVrrVrrFrrHrrGrrCr?rFrfr)rZrVr^rFr?r5rerg)r#rVr?r5)rr4rrkr^rFr?zAsyncJob[FunctionVersion]rm)r^rFryrGrrHr?zAsyncListing[FunctionVersion]ro)rZrVrrVr^rFr?zTuple[bool, AsyncJob]rq)r^rFryrGrrHr?rrsrtru)ryrGrrHr?zAsyncListing[JobInfo]ryrz)r[rVr_rFr2r{r?rN)r[rVr_rFr2r{r?rzr}rj)=rrrr~rrrhrorsrlrrr,r{rrrrrrrrErrrrrrrrrrrr$rrrrrr r rrrrrrrr r'r*r.r0r8r5r>rrr r2rrrrrrs>!&%/3$(# 8+8"8 8  8H#/3 1!11- 1 ! 1@#"& /!// /  /<3'3 "3(/3$(# !4+!4"!4 !4  !4L/3%)# * ,* # *  *  * ^ $9=9=#'(,&*48n%/3GK"&*.n%n%n%7 n% 7 n% ! n%&n%$n%2n%,n%En% n%(n% n%h/348*."&*.-1 $!%NN, N 2 N ( N N(N+NNN N`&    $ !##"/39="8"8'"8  "8  "8"8"8-"8(7"8 "8R!##"/39=  '       - (7   D.2t * ?L  */3 V V, V  V&/3   ,    26:(,$(0!0!0! 3 0! & 0!"0!0! 0!l3726    0  0  J/3$ ,   B/3   ,    " I<59.2 <!<2 < , < # <</3      ,    /3$($(  , "  "  '  >/3 NN N , N  N/3 && & , &  &&OS    #  8K    OS    #  8K    "/3$($(  , "  "    ,CG  ,?  CG    ,?    OS    #  8K    CG  ,?  CGFF,?F F/3   ,    (/3$($(  , "  "    ,.2t  *  ?L    4347;04 ((!4 ( . ( (07;04   !4  .    .:G&[#/  ,  ,rr)r`z7Tuple[str, List[str], str, str, List[str], 'pa.Schema']r?rM)w __future__rabcrr:datetimerpathlibrrtypingrrr r r r r rrrruuidr version_inforr overrideslancedb.listingrrr r!r"r#r$lancedb.embeddings.registryr%lancedb.commonr&r'r(lancedb.background_loopr)lance_namespacer*r+r,r-r.rlance_namespace.errorsr/r0r2_lancedbr functionsr3r4rr5r6r7sqlr8rzr9r|r:r;r<materialized_viewr=r>r?r@rArrBrCrDrErCrFrGrHrIutilrJrKrrMrpyarrowpaarrowrNpydanticrOrPrrQcommonrRrS embeddingsrTrUnamespace_utilsrVrWrXrarcrobjectrrrrrs/ #     w  5BHH(N05**,"FF  "-$9!!3!F,LS#LS^$}/ }/@A,fA,r