feat(python): add namespace_client() method to connection classes

Add namespace_client() method that returns the equivalent namespace client
for different connection types:
- Native storage (LanceDBConnection): returns DirectoryNamespace
- Namespace connection: returns the backing namespace client
- Enterprise connection (RemoteDBConnection): returns RestNamespace

Implementation uses a hybrid approach:
- Rust side exposes namespace_client_config() returning (impl, properties)
- Python side uses lance_namespace.connect() to construct the namespace

Changes:
- Add namespace_client_config() to Database trait and implementations
- Add PyO3 binding for namespace_client_config()
- Add namespace_client() to DBConnection, LanceDBConnection, AsyncConnection
- Add namespace_client() to RemoteDBConnection
- Add namespace_client() to LanceNamespaceDBConnection and async variant
- Add tests for namespace_client() functionality
- Update pylance dependency to >=5.0.0b5

Generated with [Claude Code](https://claude.ai/code)
via [Happy](https://happy.engineering)

Co-Authored-By: Claude <noreply@anthropic.com>
Co-Authored-By: Happy <yesreply@happy.engineering>

python/pyproject.toml

@@ -45,7 +45,7 @@ repository = "https://github.com/lancedb/lancedb"
 
 [project.optional-dependencies]
 pylance = [
-    "pylance>=5.0.0b3",
+    "pylance>=5.0.0b5",
 ]
 tests = [
     "aiohttp>=3.9.0",
@@ -59,7 +59,7 @@ tests = [
     "polars>=0.19, <=1.3.0",
     "tantivy>=0.20.0",
     "pyarrow-stubs>=16.0",
-    "pylance>=5.0.0b3",
+    "pylance>=5.0.0b5",
     "requests>=2.31.0",
     "datafusion>=52,<53",
 ]

python/python/lancedb/_lancedb.pyi

@@ -151,6 +151,9 @@ class Connection(object):
     async def drop_all_tables(
         self, namespace_path: Optional[List[str]] = None
     ) -> None: ...
+    async def namespace_client_config(
+        self,
+    ) -> Dict[str, Any]: ...
 
 class Table:
     def name(self) -> str: ...

python/python/lancedb/db.py

@@ -23,11 +23,13 @@ from lancedb.embeddings.registry import EmbeddingFunctionRegistry
 from lancedb.common import data_to_reader, sanitize_uri, validate_schema
 from lancedb.background_loop import LOOP
 from lance_namespace import (
+    LanceNamespace,
     ListNamespacesResponse,
     CreateNamespaceResponse,
     DropNamespaceResponse,
     DescribeNamespaceResponse,
     ListTablesResponse,
+    connect as namespace_connect,
 )
 
 from . import __version__
@@ -507,6 +509,26 @@ class DBConnection(EnforceOverrides):
     def uri(self) -> str:
         return self._uri
 
+    def namespace_client(self) -> LanceNamespace:
+        """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.
+        """
+        raise NotImplementedError(
+            "namespace_client is not supported for this connection type"
+        )
+
 
 class LanceDBConnection(DBConnection):
     """
@@ -1044,6 +1066,20 @@ class LanceDBConnection(DBConnection):
             )
         )
 
+    @override
+    def namespace_client(self) -> LanceNamespace:
+        """Get the equivalent namespace client for this connection.
+
+        Returns a DirectoryNamespace pointing to the same root with the
+        same storage options.
+
+        Returns
+        -------
+        LanceNamespace
+            The namespace client for this connection.
+        """
+        return LOOP.run(self._conn.namespace_client())
+
     @deprecation.deprecated(
         deprecated_in="0.15.1",
         removed_in="0.17",
@@ -1716,6 +1752,25 @@ class AsyncConnection(object):
             namespace_path = []
         await self._inner.drop_all_tables(namespace_path=namespace_path)
 
+    async def namespace_client(self) -> LanceNamespace:
+        """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.
+        """
+        config = await self._inner.namespace_client_config()
+        return namespace_connect(config["impl"], config["properties"])
+
     @deprecation.deprecated(
         deprecated_in="0.15.1",
         removed_in="0.17",

python/python/lancedb/namespace.py

@@ -890,6 +890,20 @@ class LanceNamespaceDBConnection(DBConnection):
             pushdown_operations=self._pushdown_operations,
         )
 
+    @override
+    def namespace_client(self) -> LanceNamespace:
+        """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.
+        """
+        return self._namespace_client
+
 
 class AsyncLanceNamespaceDBConnection:
     """
@@ -1387,6 +1401,19 @@ class AsyncLanceNamespaceDBConnection:
             page_token=response.page_token,
         )
 
+    async def namespace_client(self) -> LanceNamespace:
+        """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.
+        """
+        return self._namespace_client
+
 
 def connect_namespace(
     namespace_client_impl: str,

python/python/lancedb/remote/db.py

@@ -24,6 +24,7 @@ from ..common import DATA
 from ..db import DBConnection, LOOP
 from ..embeddings import EmbeddingFunctionConfig
 from lance_namespace import (
+    LanceNamespace,
     CreateNamespaceResponse,
     DescribeNamespaceResponse,
     DropNamespaceResponse,
@@ -570,6 +571,19 @@ class RemoteDBConnection(DBConnection):
             )
         )
 
+    @override
+    def namespace_client(self) -> LanceNamespace:
+        """Get the equivalent namespace client for this connection.
+
+        Returns a RestNamespace with the same URI and authentication headers.
+
+        Returns
+        -------
+        LanceNamespace
+            The namespace client for this connection.
+        """
+        return LOOP.run(self._conn.namespace_client())
+
     async def close(self):
         """Close the connection to the database."""
         self._conn.close()

python/python/tests/test_db.py

@@ -1048,3 +1048,57 @@ def test_clone_table_deep_clone_fails(tmp_path):
     source_uri = os.path.join(tmp_path, "source.lance")
     with pytest.raises(Exception, match="Deep clone is not yet implemented"):
         db.clone_table("cloned", source_uri, is_shallow=False)
+
+
+def test_namespace_client_native_storage(tmp_path):
+    """Test namespace_client() returns DirectoryNamespace for native storage connections."""
+    from lance.namespace import DirectoryNamespace
+
+    db = lancedb.connect(tmp_path)
+    ns_client = db.namespace_client()
+
+    assert isinstance(ns_client, DirectoryNamespace)
+    assert str(tmp_path) in ns_client.namespace_id()
+
+
+def test_namespace_client_with_storage_options(tmp_path):
+    """Test namespace_client() preserves storage options."""
+    from lance.namespace import DirectoryNamespace
+
+    storage_options = {"timeout": "10s"}
+    db = lancedb.connect(tmp_path, storage_options=storage_options)
+    ns_client = db.namespace_client()
+
+    assert isinstance(ns_client, DirectoryNamespace)
+
+
+def test_namespace_client_operations(tmp_path):
+    """Test that namespace_client() returns a functional namespace client."""
+    db = lancedb.connect(tmp_path)
+    ns_client = db.namespace_client()
+
+    # Create a table through the main db connection
+    data = [{"id": 1, "text": "hello", "vector": [1.0, 2.0]}]
+    db.create_table("test_table", data=data)
+
+    # Verify the namespace client can see the table
+    from lance_namespace import ListTablesRequest
+
+    # id=[] means root namespace
+    response = ns_client.list_tables(ListTablesRequest(id=[]))
+    # Tables can be strings or objects with name attribute
+    table_names = [
+        t.name if hasattr(t, "name") else t for t in response.tables
+    ]
+    assert "test_table" in table_names
+
+
+def test_namespace_client_namespace_connection(tmp_path):
+    """Test namespace_client() returns the backing client for namespace connections."""
+    from lance.namespace import DirectoryNamespace
+
+    db = lancedb.connect_namespace("dir", {"root": str(tmp_path)})
+    ns_client = db.namespace_client()
+
+    assert isinstance(ns_client, DirectoryNamespace)
+    assert str(tmp_path) in ns_client.namespace_id()

python/src/connection.rs

@@ -474,6 +474,25 @@ impl Connection {
             })
         })
     }
+
+    /// Get the configuration for constructing an equivalent namespace client.
+    /// Returns a dict with:
+    /// - "impl": "dir" for DirectoryNamespace, "rest" for RestNamespace
+    /// - "properties": configuration properties for the namespace
+    #[pyo3(signature = ())]
+    pub fn namespace_client_config(self_: PyRef<'_, Self>) -> PyResult<Bound<'_, PyAny>> {
+        let inner = self_.get_inner()?.clone();
+        let py = self_.py();
+        future_into_py(py, async move {
+            let (impl_type, properties) = inner.namespace_client_config().await.infer_error()?;
+            Python::attach(|py| -> PyResult<Py<PyDict>> {
+                let dict = PyDict::new(py);
+                dict.set_item("impl", impl_type)?;
+                dict.set_item("properties", properties)?;
+                Ok(dict.unbind())
+            })
+        })
+    }
 }
 
 #[pyfunction]

rust/lancedb/src/connection.rs

@@ -541,6 +541,16 @@ impl Connection {
         self.internal.namespace_client().await
     }
 
+    /// Get the configuration for constructing an equivalent namespace client.
+    /// Returns (impl_type, properties) where:
+    /// - impl_type: "dir" for DirectoryNamespace, "rest" for RestNamespace
+    /// - properties: configuration properties for the namespace
+    pub async fn namespace_client_config(
+        &self,
+    ) -> Result<(String, std::collections::HashMap<String, String>)> {
+        self.internal.namespace_client_config().await
+    }
+
     /// List tables with pagination support
     pub async fn list_tables(&self, request: ListTablesRequest) -> Result<ListTablesResponse> {
         self.internal.list_tables(request).await

rust/lancedb/src/database.rs

@@ -265,4 +265,13 @@ pub trait Database:
     /// For ListingDatabase, it is the equivalent DirectoryNamespace.
     /// For RemoteDatabase, it is the equivalent RestNamespace.
     async fn namespace_client(&self) -> Result<Arc<dyn LanceNamespace>>;
+
+    /// Get the configuration for constructing an equivalent namespace client.
+    /// Returns (impl_type, properties) where:
+    /// - impl_type: "dir" for DirectoryNamespace, "rest" for RestNamespace
+    /// - properties: configuration properties for the namespace
+    ///
+    /// This is useful for Python bindings where we want to return a Python
+    /// namespace object rather than a Rust trait object.
+    async fn namespace_client_config(&self) -> Result<(String, HashMap<String, String>)>;
 }

rust/lancedb/src/database/listing.rs

@@ -1099,6 +1099,15 @@ impl Database for ListingDatabase {
         })?;
         Ok(Arc::new(namespace) as Arc<dyn lance_namespace::LanceNamespace>)
     }
+
+    async fn namespace_client_config(&self) -> Result<(String, HashMap<String, String>)> {
+        let mut properties = HashMap::new();
+        properties.insert("root".to_string(), self.uri.clone());
+        for (key, value) in &self.storage_options {
+            properties.insert(format!("storage.{}", key), value.clone());
+        }
+        Ok(("dir".to_string(), properties))
+    }
 }
 
 #[cfg(test)]

rust/lancedb/src/database/namespace.rs

@@ -45,6 +45,10 @@ pub struct LanceNamespaceDatabase {
     uri: String,
     // Operations to push down to the namespace server
     pushdown_operations: HashSet<PushdownOperation>,
+    // Namespace implementation type (e.g., "dir", "rest")
+    ns_impl: String,
+    // Namespace properties used to construct the namespace client
+    ns_properties: HashMap<String, String>,
 }
 
 impl LanceNamespaceDatabase {
@@ -74,6 +78,8 @@ impl LanceNamespaceDatabase {
             session,
             uri: format!("namespace://{}", ns_impl),
             pushdown_operations,
+            ns_impl: ns_impl.to_string(),
+            ns_properties,
         })
     }
 }
@@ -345,6 +351,10 @@ impl Database for LanceNamespaceDatabase {
     async fn namespace_client(&self) -> Result<Arc<dyn LanceNamespace>> {
         Ok(self.namespace.clone())
     }
+
+    async fn namespace_client_config(&self) -> Result<(String, HashMap<String, String>)> {
+        Ok((self.ns_impl.clone(), self.ns_properties.clone()))
+    }
 }
 
 #[cfg(test)]

rust/lancedb/src/remote/db.rs

@@ -777,6 +777,32 @@ impl<S: HttpSend> Database for RemoteDatabase<S> {
         let namespace = builder.build();
         Ok(Arc::new(namespace) as Arc<dyn lance_namespace::LanceNamespace>)
     }
+
+    async fn namespace_client_config(&self) -> Result<(String, HashMap<String, String>)> {
+        let mut properties = HashMap::new();
+        properties.insert("uri".to_string(), self.client.host().to_string());
+        properties.insert("delimiter".to_string(), self.client.id_delimiter.clone());
+        for (key, value) in &self.namespace_headers {
+            properties.insert(format!("header.{}", key), value.clone());
+        }
+        // Add TLS configuration if present
+        if let Some(tls_config) = &self.tls_config {
+            if let Some(cert_file) = &tls_config.cert_file {
+                properties.insert("tls.cert_file".to_string(), cert_file.clone());
+            }
+            if let Some(key_file) = &tls_config.key_file {
+                properties.insert("tls.key_file".to_string(), key_file.clone());
+            }
+            if let Some(ssl_ca_cert) = &tls_config.ssl_ca_cert {
+                properties.insert("tls.ssl_ca_cert".to_string(), ssl_ca_cert.clone());
+            }
+            properties.insert(
+                "tls.assert_hostname".to_string(),
+                tls_config.assert_hostname.to_string(),
+            );
+        }
+        Ok(("rest".to_string(), properties))
+    }
 }
 
 /// RemoteOptions contains a subset of StorageOptions that are compatible with Remote LanceDB connections