IZjhdZddlmZddlZddlmZmZmZmZm Z m Z m Z ej dkrddlm Z nddlm Z erddlmZddlmZddlZdd lmZdd lmZdd lmZdd lmZdd lmZddlm Z ddl!m"Z"ddl#m$Z$ddl%m&Z&ddl'm(Z)ddl*m+Z+ddl,m-Z-m.Z.ddl/m0Z0m1Z1m2Z2ddl3m4Z4m5Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAddlBmCZCmDZDmEZEddlFmGZGddlHmIZIddlJmKZKddlLmMZMddlNmOZOdTd$ZPdUd(ZQ dVdWd6ZRdXd8ZSdYd:ZTdZd>ZUd[dAZVGdBdCe.ZWGdDdEZXdddddFd\dRZYdddddFd]dSZZdS)^z LanceDB Namespace integration module. This module provides integration with lance_namespace for managing tables through a namespace abstraction. ) annotationsN) TYPE_CHECKINGAnyDictIterableListOptionalUnion) )overrideQuery) timedelta)JsonArrowDataType)JsonArrowField)JsonArrowSchema)QueryTableRequest)QueryTableRequestColumns)QueryTableRequestFullTextQuery)QueryTableRequestVector)StringFtsQuery)TableNotFoundError)connect_namespace_client)LOOP)AsyncConnection DBConnection) _normalize_create_namespace_mode_normalize_drop_namespace_mode"_normalize_drop_namespace_behavior) LanceNamespaceconnectCreateNamespaceResponseDescribeNamespaceResponseDropNamespaceResponseListNamespacesResponseListTablesResponseListTablesRequestDescribeNamespaceRequestDropTableRequestListNamespacesRequestCreateNamespaceRequestDropNamespaceRequest) AsyncTable LanceTableTable)validate_table_name)DATA) LanceModel)EmbeddingFunctionConfig)Sessiontable_id List[str]query'Query'returnrc Vddlm}t||stdt |d}|jt|jt jr|j}n_t|jtr>|jr7t|jdt jrd|jD}n|j}t|tr.|r,t|dtrt|}nt|}d}|j Et|j trt|j }nt|j }d}|j|j}t|trt!t#|  }nKt%|d r;t!t#|jt%|d r|j nd }d}|j|j }|j|jnd} || ||n td} |j |j| d<|j |j| d<||| d<||| d<||| d <|j |j| d<|j |j| d<|j |j| d<|j |j| d<|j |j| d<|j |j| d<|j |j| d<|j |j| d<|j |j | d<|j! |j!| d<tEdi| S) a^ Convert a LanceDB Query object to a QueryTableRequest for server-side query. Parameters ---------- table_id : List[str] The table identifier (namespace path + table name) query : Query The LanceDB Query object to convert Returns ------- QueryTableRequest The namespace QueryTableRequest rrzExpected Query, got Nc6g|]}|S) to_pylist).0vs ]/Users/jameslopez/projects/MentorCore/.venv/lib/python3.11/site-packages/lancedb/namespace.py z/_query_to_namespace_request..js ???Q1;;==???) multi_vector) single_vector)column_aliases) column_names)r9) string_queryr9columns)r9rJ )idkvector vector_columnfilter prefilterfull_text_queryoffset with_row_idefnprobes refine_factor lower_bound upper_boundbypass_vector_index fast_search distance_typer>)# lancedb.queryr isinstance TypeErrortyperNpaArrayr?listrrJdictrrRstrrrhasattrr9 postfilterlimitrOrPrSrTrUminimum_nprobesrWrXrYrZr[r\r) r7r9rvector_request vector_listcolumns_requestfull_text_query_request fts_queryrQrMkwargss rB_query_to_namespace_requestrpIs&$##### eU # #>400 P 5+NNNNN4;OOONO } emT * * S6emTTTOO6EMRRRO" () i % % &D+)<<<''' # #Y ( ( &D+#/y)44I-- ''' #I #(( {. BA    %!. $ & & F &"'"5 | <x'{*$; !"+y | <x $ % 1} xxt  (!1y &"'"5 $ % 1} $ % 1}  ,(-(A$% $ % 1} &"'"5  & &v & &&rDnamespace_clientr!pa.RecordBatchReadercjt||}||}t|S)a Execute a query on the namespace server and return results as RecordBatchReader. Parameters ---------- namespace_client : LanceNamespace The namespace client to use table_id : List[str] The table identifier (namespace path + table name) query : Query The LanceDB Query object Returns ------- pa.RecordBatchReader The query results as a RecordBatchReader )rp query_table!_arrow_ipc_to_record_batch_reader)rqr7r9request ipc_bytess rB_execute_server_side_queryrxs4,*(E::G ,,W55I ,Y 7 77rDerrordataOptional['DATA']schema&Optional[Union[pa.Schema, LanceModel]]embedding_functions'Optional[List[EmbeddingFunctionConfig]]on_bad_vectorsre fill_valuefloatbytescddlm}ddlm}t |t r)t |tr|}| }|r| |}n ||j }nd}||td|r| |}tj} tj| |5} dddn #1swxYwY| S||||||} tj} tj| | j5} | D]} | |  dddn #1swxYwY| S)a? Convert data to Arrow IPC format (file format) for server-side create_table. If data is None but schema is provided, creates an empty IPC stream with just the schema in the header (zero batches). This is used to create empty tables with just a schema. Returns the serialized Arrow IPC bytes. r)EmbeddingFunctionRegistry)_sanitize_dataNz>Either data or schema is required for server-side create_table) target_schemametadatarr)lancedb.embeddingsr lancedb.tablerr^r` issubclassr3to_arrow_schema get_instanceget_table_metadatar ValueError with_metadataraBufferOutputStreamipc new_streamgetvalue to_pybytesr} write_batch) r{r}rrrrrregistryrsinkwriterreaderbatchs rB_data_to_arrow_ipcrs\ =<<<<<,,,,,,&$*Jvz$B$B*'')))5577H../BCC  ? | >P   4))(33F$&& V  tV , ,                 }}))+++ ^ % F  " "D   4 / /&6 & &E   u % % % % &&&&&&&&&&&&&&&& ==?? % % ' ''s$ C..C25C2'FFFrwctj|}tj|fdt jD}tjj|S)z9 Convert Arrow IPC bytes to a RecordBatchReader. c:g|]}|Sr>) get_batch)r@irs rBrCz5_arrow_ipc_to_record_batch_reader..s'MMMqv""MMMrD) ra py_bufferr open_filerangenum_record_batchesRecordBatchReader from_batchesr})rwbufbatchesrs @rBrurush ,y ! !C V  c " "FMMMME&2K,L,LMMMG  , ,V]G D DDrDmodecp|}|dkrdS|dkrdStd|d)z5Normalize create table mode string for namespace API.createCreate overwrite OverwritezInvalid mode: z!. Must be 'create' or 'overwrite')lowerr)r mode_lowers rB_normalize_create_table_moder#sIJXx { " "{Q$QQQRRRrD arrow_type pa.DataTyperctj|rd}ntj|rd}ntj|rd}ntj|rd}ntj|rd}ntj|rd}netj|rd}nBtj |rd}ntj |rd }ntj |rd }ntj |rd }ntj |rd }ntj|rd }nutj|rd}nStj|rd}n1tj|rd}nt%|}t'|S)z.Convert PyArrow DataType to JsonArrowDataType.nullboolint8uint8int16uint16int32uint32int64uint64float32float64utf8binaryrcfixed_size_list)r`)ratypesis_null is_booleanis_int8is_uint8is_int16 is_uint16is_int32 is_uint32is_int64 is_uint64 is_float32 is_float64 is_string is_binaryis_listis_fixed_size_listrer)r type_names rB_convert_pyarrow_type_to_jsonr.s x ###$   Z ( (!$   * % %$   : & &$   : & &$   J ' '$   : & &$   J ' '$   : & &$   J ' '$   Z ( ($   Z ( ( $   J ' ' $   J ' ' $   * % %$  $ $Z 0 0$%  OO ) , , ,,rD pa.Schemarcg}|D]K}t|jt|j|j|j}||Ld}|jr#d|jD}t||S)z*Convert PyArrow Schema to JsonArrowSchema.)namer`nullablerNcfi|].\}}|d|d/S)zutf-8)decode)r@rMrAs rB z3_convert_pyarrow_schema_to_json..gsC   59QAHHW  qxx00   rD)fieldsr) rrrr`rrappenditemsr)r}rfield json_fieldmetas rB_convert_pyarrow_schema_to_jsonrXs F""#.uz::^^     j!!!! D    =C_=R=R=T=T    &4 8 8 88rDceZdZdZddddddddTdZedUdZe dVdddWdZe dXddddd!dYd3Zedddd4dZd7Z ed[d\d8Z e d]d^d=Z ed>Z ed[d_d?Z e d`dadAZe d]dbdEZe d]dcdHZedddJZe d`dedLZddddddMdfdRZedgdSZdS)hLanceNamespaceDBConnectionz A LanceDB connection that uses a namespace for table management. This connection delegates table URI resolution to a lance_namespace instance, while using the standard LanceTable for actual table operations. Nread_consistency_intervalstorage_optionssession$namespace_client_pushdown_operationsnamespace_client_implnamespace_client_propertiesrqr!rOptional[timedelta]rOptional[Dict[str, str]]rOptional[Session]rOptional[List[str]]r Optional[str]rc 8||_||_|pi|_||_t |pg|_||_||_tt||| nd|jpd|t|j|||_ dS)a Initialize a namespace-based LanceDB connection. Parameters ---------- namespace_client : LanceNamespace The namespace client to use for table management read_consistency_interval : Optional[timedelta] The interval at which to check for updates to the table from other processes. If None, then consistency is not checked. storage_options : Optional[Dict[str, str]] Additional options for the storage backend session : Optional[Session] A session to use for this connection namespace_client_pushdown_operations : Optional[List[str]] List of namespace operations to push down to the namespace server. Supported values: - "QueryTable": Execute queries on the namespace server via namespace.query_table() instead of locally. - "CreateTable": Execute table creation on the namespace server via namespace.create_table() instead of using declare_table + local write. Default is None (no pushdown, all operations run locally). namespace_client_impl : Optional[str] The namespace implementation name used to create this connection. Stored for serialization purposes. namespace_client_properties : Optional[Dict[str, str]] The namespace properties used to create this connection. Stored for serialization purposes. Nr) _namespace_clientrrrset%_namespace_client_pushdown_operations_namespace_client_impl_namespace_client_propertiesr_connect_namespace_client total_secondsrc_inner)selfrqrrrrrrs rB__init__z#LanceNamespaceDBConnection.__init__vsT"2)B&.4" 58 0 6B6 6 2'<#,G)% % 1<.;;=== $ 4 <CDD&;,G      rDr;rec ddl}|d|j|jt |j|jpd|jr|jnddS)Nr namespace)connection_typerrrr!read_consistency_interval_seconds) jsondumpsrrsortedrrrr)rrs rB serializez$LanceNamespaceDBConnection.serializes~ zz#.)-)D/3/P8>>99$(#7#?45D2@@BBB     rDrKnamespace_path page_tokenrhintr Iterable[str]cddl}|dtd|g}t|||}|j|}|jr|jngS)z List table names in the database. .. deprecated:: Use :meth:`list_tables` instead, which provides proper pagination support. rN6table_names() is deprecated, use list_tables() instead stacklevelrLr rhwarningswarnDeprecationWarningr(r list_tablestablesrr rhrrrvresponses rB table_namesz&LanceNamespaceDBConnection.table_namess  D      !N#*E   )55g>>"*/9xr9rDrFryrzrrdata_storage_versionenable_v2_manifest_pathsrr{Optional[DATA]r}r~rexist_okrrrrrrrrOptional[bool]r0c | g} |dvrtdt|tj|j||||||||| |  } t||| |j|j | S)Nrr+mode must be either 'create' or 'overwrite')r}rrrrrrrrrqpushdown_operations_async) rrr1rrunr create_tabler/rr)rrr{r}rrrrrrrrr async_tables rBr(z'LanceNamespaceDBConnection.create_tables"  !N ::<<6 6 6JKK KD!!!h K $ $!-%$7- / %       )!3 $ J     rDrrindex_cache_sizer+ Optional[int]cJ|g} tj|j||||}nO#t$rB}dt |vr+||gz}t dd|d}~wwxYwt||||j |j |S)Nr*Table not foundTable not found: $r$) rr'r open_table RuntimeErrorrerjoinr/rr)rrrrr+r)er7s rBr1z%LanceNamespaceDBConnection.open_tables  !N ( &&#1$3%5 'KK    CFF**)TF2()QSXXh=O=O)Q)QRRR      )!3 $ J     s07 B=A>>Bcn|g}||gz}t|}|j|dS)NrLr*r drop_tablerrrr7rvs rBr8z%LanceNamespaceDBConnection.drop_table>sH  !N!TF*"h/// ))'22222rDcur_namenew_namecur_namespace_pathnew_namespace_pathc0|g}|g}td)N7rename_table is not supported for namespace connectionsNotImplementedErrorrr:r;r<r=s rB rename_tablez'LanceNamespaceDBConnection.rename_tableGs1  %!#   %!# ! E   rDc td)N8drop_database is deprecated, use drop_all_tables insteadr@rs rB drop_databasez(LanceNamespaceDBConnection.drop_databaseWs! F   rDcn|g}||D]}|||dS)Nrrr8)rr table_names rBdrop_all_tablesz*LanceNamespaceDBConnection.drop_all_tables]sT  !N**.*II G GJ OOJ~O F F F F G GrDr&c|g}t|||}|j|}t|jr|jng|jSa List child namespaces under the given namespace. Parameters ---------- namespace_path : Optional[List[str]] The parent namespace path to list children from. If None, lists root-level namespaces. page_token : Optional[str] Token for pagination. Use the token from a previous response to get the next page of results. limit : int, optional Maximum number of namespaces to return. Returns ------- ListNamespacesResponse Response containing namespace names and optional page_token for pagination. Nr) namespacesr r+rlist_namespacesr&rNr rrr rhrvrs rBrPz*LanceNamespaceDBConnection.list_namespacesdsr4  !N'*E   )99'BB%.6.AIx**r*    rDr8 propertiesr#ct|t||}|j|}t t |dr|jndSa8 Create a new namespace. Parameters ---------- namespace_path : List[str] The namespace path 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. )rLrrRrRNrRr,rrcreate_namespacer#rfrRrrrrRrvrs rBrWz+LanceNamespaceDBConnection.create_namespacess2)1$77!    )::7CC&.5h .M.MWx**SW    rDbehaviorr%c t|t|t|}|j|}t t |dr|jndt |dr|jndSa+ Drop a namespace. Parameters ---------- namespace_path : List[str] The namespace path 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. )rLrrYrRNtransaction_id)rRr\ r-rr rdrop_namespacer%rfrRr\rrrrYrvrs rBr^z)LanceNamespaceDBConnection.drop_namespaces2'/557AA    )88AA$'.x'F'FP##D,38=M+N+NX''TX     rDr$ct|}|j|}tt |dr|jndSa  Describe a namespace. Parameters ---------- namespace_path : List[str] The namespace identifier to describe. Returns ------- DescribeNamespaceResponse Response containing the namespace properties. r6rRNrUr)rdescribe_namespacer$rfrRrrrvrs rBrcz-LanceNamespaceDBConnection.describe_namespaces\"+n===)<>!&.o=8??2*    rD)rrr+rqmanaged_versioning table_uri Optional[Any]rhr/c |g}tj|j||||d||}t |||||||j|S)N)rrr+locationrqrh)rrlrqrhr%r&)rr'rr1r/r) rrrirrr+rqrhr)s rB_lance_table_from_uriz0LanceNamespaceDBConnection._lance_table_from_uris  !Nh K " "- /!1!1#5 #       )-1 $ J    rDc|jSa!Get the namespace client for this connection. For namespace connections, this returns the backing namespace client that was provided during construction. Returns ------- LanceNamespace The namespace client for this connection. rrFs rBrqz+LanceNamespaceDBConnection.namespace_client9s %%rD)rqr!rrrrrrrrrrrr)r;reNrKr rrhr rrr;r NNrFryrzN)rrer{rr}r~rrerrrrerrrrrrrrrrrr r;r0) rrerrrrr+r,r;r0NrrerrNNr:rer;rer<rr=rrrNNNrrr rrhr,r;r&rr8rrrRrr;r#rr8rrrYrr;r%rr8r;r$rrr rrhr,r;r')rrerirerrrrr+r,rqrjrhr r;r/r;r!)__name__ __module__ __qualname____doc__rr rrr(r1r8rCrGrKrPrWr^rcrrmrqr>rDrBrrns:>48%)DH/3@DC C C C C C J   X (%): /3 :::::X:8 $9=%GK+ /348.237+ + + + + X+ Z /348*.      X  D3333X3 3726     X    X GGGGXG /3$(# " " " " X" H#/3     X  D#"& % % % % X% N   X ,/3$(# " " " " X" R/348*.*.-1' ' ' ' ' ' R & & &X & & &rDrceZdZdZddddddKdZ dLdddMdZ dNddddddOd0Zdddd1dPd4ZdQdRd5Z dSdTd:Z d;Z dQdUd<Z dVdWd>Z dSdXdBZ dSdYdEZdZdGZ dVd[dIZd\dJZdS)]AsyncLanceNamespaceDBConnectionz An async LanceDB connection that uses a namespace for table management. This connection delegates table URI resolution to a lance_namespace instance, while providing async methods for all operations. Nrrrrrqr!rrrrrrrrc ||_||_|pi|_||_t |pg|_t t|||nd|jpd|t|jdd|_ dS)a~ Initialize an async namespace-based LanceDB connection. Parameters ---------- namespace_client : LanceNamespace The namespace client to use for table management read_consistency_interval : Optional[timedelta] The interval at which to check for updates to the table from other processes. If None, then consistency is not checked. storage_options : Optional[Dict[str, str]] Additional options for the storage backend session : Optional[Session] A session to use for this connection namespace_client_pushdown_operations : Optional[List[str]] List of namespace operations to push down to the namespace server. Supported values: - "QueryTable": Execute queries on the namespace server via namespace.query_table() instead of locally. - "CreateTable": Execute table creation on the namespace server via namespace.create_table() instead of using declare_table + local write. Default is None (no pushdown, all operations run locally). Nr) rrrrrrrrrrcr)rrqrrrrs rBrz(AsyncLanceNamespaceDBConnection.__init__PsD"2)B&.4" 58 0 6B6 6 2& % 1<.;;=== $ 4 <CDD&*,0      rDrKrr rrhr rr;r cKddl}|dtd|g}t|||}|j|}|jr|jngS)z List table names in the namespace. .. deprecated:: Use :meth:`list_tables` instead, which provides proper pagination support. rNr rrrrrs rBrz+AsyncLanceNamespaceDBConnection.table_namess  D      !N#*E   )55g>>"*/9xr9rDrFryrzrrrer{rr}r~rrrrrrrrrrr r.c  K| g} |dvrtdt||j|||||||| ||  d{VS)z$Create a new table in the namespace.Nr"r#)r}rrrrrrr)rrr1rr() rrr{r}rrrrrrrrrs rBr(z,AsyncLanceNamespaceDBConnection.create_tables"  !N ::<<6 6 6JKK KD!!![--  )!) 3+.         rDr*r+r,cK|g} |j||||d{VS#t$rB}dt|vr+||gz}t dd|d}~wwxYw)z*Open an existing table from the namespace.Nr*r.r/r0)rr1r2rerr3)rrrrr+r4r7s rBr1z*AsyncLanceNamespaceDBConnection.open_tables  !N //- /!1 0      CFF**)TF2()QSXXh=O=O)Q)QRRR   s#, A8=A33A8crK|g}||gz}t|}|j|dS)z Drop a table from the namespace.Nr6r7r9s rBr8z*AsyncLanceNamespaceDBConnection.drop_tablesJ  !N!TF*"h/// ))'22222rDr:r;r<r=c4K|g}|g}td)z2Rename is not supported for namespace connections.Nr?r@rBs rBrCz,AsyncLanceNamespaceDBConnection.rename_tables5  %!#   %!# ! E   rDc$Ktd)zDeprecated method.rEr@rFs rBrGz-AsyncLanceNamespaceDBConnection.drop_databases! F   rDcK|g}||d{V}|D]}|||d{V dS)z!Drop all tables in the namespace.NrrI)rrrrJs rBrKz/AsyncLanceNamespaceDBConnection.drop_all_tabless  !N ,,N,KKKKKKKK % M MJ//*^/LL L L L L L L L L M MrDr&cK|g}t|||}|j|}t|jr|jng|jSrMrOrQs rBrPz/AsyncLanceNamespaceDBConnection.list_namespacessv2  !N'*E   )99'BB%.6.AIx**r*    rDr8rRr#cKt|t||}|j|}t t |dr|jndSrTrVrXs rBrWz0AsyncLanceNamespaceDBConnection.create_namespace,sw0)1$77!    )::7CC&.5h .M.MWx**SW    rDrYr%cKt|t|t|}|j|}t t |dr|jndt |dr|jndSr[r]r_s rBr^z.AsyncLanceNamespaceDBConnection.drop_namespaceNs0'/557AA    )88AA$'.x'F'FP##D,38=M+N+NX''TX     rDr$cKt|}|j|}tt |dr|jndSrarbrds rBrcz2AsyncLanceNamespaceDBConnection.describe_namespaceus` +n===)<>!&.o=8??2*    rDcK|jSrorprFs rBrqz0AsyncLanceNamespaceDBConnection.namespace_clients%%rD) rqr!rrrrrrrrrqrrrs)rrer{rr}r~rrerrrrerrrrrrrrrrrr r;r.) rrerrrrr+r,r;r.rtrurvrwrxryrzr{r|r}r~r)rrrrrrr(r1r8rCrGrKrPrWr^rcrrqr>rDrBrrHs :>48%)DH9 9 9 9 9 9 z%): /3 ::::::> $9=%GK! /348.237! ! ! ! ! ! N/348*. 0333333726         MMMMM/3$(# " " " " " N#/3      J#"& % % % % % N    0/3$(# " " " " " H & & & & & &rDrrrrDict[str, str]rrrrrrrrc Nt||}t|||||||S)a1 Connect to a LanceDB database through a namespace. Parameters ---------- namespace_client_impl : str The namespace client implementation to use. For examples: - "dir" for DirectoryNamespace - "rest" for REST-based namespace - Full module path for custom implementations namespace_client_properties : Dict[str, str] Configuration properties for the namespace client implementation. Different namespace implementations have different config properties. For example, use DirectoryNamespace with {"root": "/path/to/directory"} read_consistency_interval : Optional[timedelta] The interval at which to check for updates to the table from other processes. If None, then consistency is not checked. storage_options : Optional[Dict[str, str]] Additional options for the storage backend session : Optional[Session] A session to use for this connection namespace_client_pushdown_operations : Optional[List[str]] List of namespace operations to push down to the namespace server. Supported values: - "QueryTable": Execute queries on the namespace server via namespace.query_table() instead of locally. - "CreateTable": Execute table creation on the namespace server via namespace.create_table() instead of using declare_table + local write. Default is None (no pushdown, all operations run locally). Returns ------- LanceNamespaceDBConnection A namespace-based connection to LanceDB )rqrrrrrr)namespace_connectrrrrrrrrqs rBconnect_namespacersI^): &)";'-Q3$?   rDcJt||}t|||||S)aa Connect to a LanceDB database through a namespace (returns async connection). This function is synchronous but returns an AsyncLanceNamespaceDBConnection that provides async methods for all database operations. Parameters ---------- namespace_client_impl : str The namespace client implementation to use. For examples: - "dir" for DirectoryNamespace - "rest" for REST-based namespace - Full module path for custom implementations namespace_client_properties : Dict[str, str] Configuration properties for the namespace client implementation. Different namespace implementations have different config properties. For example, use DirectoryNamespace with {"root": "/path/to/directory"} read_consistency_interval : Optional[timedelta] The interval at which to check for updates to the table from other processes. If None, then consistency is not checked. storage_options : Optional[Dict[str, str]] Additional options for the storage backend session : Optional[Session] A session to use for this connection namespace_client_pushdown_operations : Optional[List[str]] List of namespace operations to push down to the namespace server. Supported values: - "QueryTable": Execute queries on the namespace server via namespace.query_table() instead of locally. - "CreateTable": Execute table creation on the namespace server via namespace.create_table() instead of using declare_table + local write. Default is None (no pushdown, all operations run locally). Returns ------- AsyncLanceNamespaceDBConnection An async namespace-based connection to LanceDB Examples -------- >>> import lancedb >>> # This function is sync, but returns an async connection >>> db = lancedb.connect_namespace_async("dir", {"root": "/path/to/db"}) >>> # Use async methods on the connection >>> async def use_db(): ... tables = await db.table_names() ... table = await db.create_table("my_table", schema=schema) )rqrrrr)rrrs rBconnect_namespace_asyncrsCx): +)";'-Q    rD)r7r8r9r:r;r)rqr!r7r8r9r:r;rr)Nryrz) r{r|r}r~rrrrerrr;r)rwrr;rr)rrer;re)rrr;r)r}rr;r)rrerrrrrrrrrrr;r)rrerrrrrrrrrrr;r)[r __future__rsystypingrrrrrr r version_infor overridesr]rdatetimerpyarrowra:lance_namespace_urllib3_client.models.json_arrow_data_typer6lance_namespace_urllib3_client.models.json_arrow_fieldr7lance_namespace_urllib3_client.models.json_arrow_schemar9lance_namespace_urllib3_client.models.query_table_requestrAlance_namespace_urllib3_client.models.query_table_request_columnsrIlance_namespace_urllib3_client.models.query_table_request_full_text_queryr@lance_namespace_urllib3_client.models.query_table_request_vectorr6lance_namespace_urllib3_client.models.string_fts_queryrlance_namespace.errorsrlancedb._lancedbrrlancedb.background_loopr lancedb.dbrrlancedb.namespace_utilsrrr lance_namespacer!r"rr#r$r%r&r'r(r)r*r+r,r-rr.r/r0 lancedb.utilr1lancedb.commonr2lancedb.pydanticr3rr4_lancedbr6rprxrrurrrrrrrr>rDrBrs#""""" LLLLLLLLLLLLLLLLLLw""""""$######XXXXXXQQQQQQSSSSSSWWWWWWRQQQQQ555555RRRRRR((((((44444444 8777777777,,,,,,''''''666666u'u'u'u'p8888<DH! :(:(:(:(:(zEEEESSSS'-'-'-'-T9999,W&W&W&W&W&W&W&W&tr&r&r&r&r&r&r&r&r 6:04!%@D;;;;;;D6:04!%@DFFFFFFFFrD