refactor!: use namespace models directly for namespace operations (#2806)

1. Use generated models in lance-namespace for request response models
to avoid multiple layers of conversions
2. Make sure the API is consistent with the namespace spec
3. Deprecate the table_names API in favor of the list_tables API in
namespace that allows full pagination support without the need to have
sorted table names
4. Add describe_namespace API which was a miss in the original
implementation

python/src/connection.rs

@@ -10,8 +10,9 @@ use lancedb::{
 };
 use pyo3::{
     exceptions::{PyRuntimeError, PyValueError},
-    pyclass, pyfunction, pymethods, Bound, FromPyObject, Py, PyAny, PyObject, PyRef, PyResult,
-    Python,
+    pyclass, pyfunction, pymethods,
+    types::{PyDict, PyDictMethods},
+    Bound, FromPyObject, Py, PyAny, PyObject, PyRef, PyResult, Python,
 };
 use pyo3_async_runtimes::tokio::future_into_py;
 
@@ -292,40 +293,155 @@ impl Connection {
         limit: Option<u32>,
     ) -> PyResult<Bound<'_, PyAny>> {
         let inner = self_.get_inner()?.clone();
-        future_into_py(self_.py(), async move {
-            use lancedb::database::ListNamespacesRequest;
+        let py = self_.py();
+        future_into_py(py, async move {
+            use lance_namespace::models::ListNamespacesRequest;
             let request = ListNamespacesRequest {
-                namespace,
+                id: if namespace.is_empty() {
+                    None
+                } else {
+                    Some(namespace)
+                },
                 page_token,
-                limit,
+                limit: limit.map(|l| l as i32),
             };
-            inner.list_namespaces(request).await.infer_error()
+            let response = inner.list_namespaces(request).await.infer_error()?;
+            Python::with_gil(|py| -> PyResult<Py<PyDict>> {
+                let dict = PyDict::new(py);
+                dict.set_item("namespaces", response.namespaces)?;
+                dict.set_item("page_token", response.page_token)?;
+                Ok(dict.unbind())
+            })
         })
     }
 
-    #[pyo3(signature = (namespace,))]
+    #[pyo3(signature = (namespace, mode=None, properties=None))]
     pub fn create_namespace(
         self_: PyRef<'_, Self>,
         namespace: Vec<String>,
+        mode: Option<String>,
+        properties: Option<std::collections::HashMap<String, String>>,
     ) -> PyResult<Bound<'_, PyAny>> {
         let inner = self_.get_inner()?.clone();
-        future_into_py(self_.py(), async move {
-            use lancedb::database::CreateNamespaceRequest;
-            let request = CreateNamespaceRequest { namespace };
-            inner.create_namespace(request).await.infer_error()
+        let py = self_.py();
+        future_into_py(py, async move {
+            use lance_namespace::models::{create_namespace_request, CreateNamespaceRequest};
+            let mode_enum = mode.and_then(|m| match m.to_lowercase().as_str() {
+                "create" => Some(create_namespace_request::Mode::Create),
+                "exist_ok" => Some(create_namespace_request::Mode::ExistOk),
+                "overwrite" => Some(create_namespace_request::Mode::Overwrite),
+                _ => None,
+            });
+            let request = CreateNamespaceRequest {
+                id: if namespace.is_empty() {
+                    None
+                } else {
+                    Some(namespace)
+                },
+                mode: mode_enum,
+                properties,
+            };
+            let response = inner.create_namespace(request).await.infer_error()?;
+            Python::with_gil(|py| -> PyResult<Py<PyDict>> {
+                let dict = PyDict::new(py);
+                dict.set_item("properties", response.properties)?;
+                Ok(dict.unbind())
+            })
+        })
+    }
+
+    #[pyo3(signature = (namespace, mode=None, behavior=None))]
+    pub fn drop_namespace(
+        self_: PyRef<'_, Self>,
+        namespace: Vec<String>,
+        mode: Option<String>,
+        behavior: Option<String>,
+    ) -> PyResult<Bound<'_, PyAny>> {
+        let inner = self_.get_inner()?.clone();
+        let py = self_.py();
+        future_into_py(py, async move {
+            use lance_namespace::models::{drop_namespace_request, DropNamespaceRequest};
+            let mode_enum = mode.and_then(|m| match m.to_uppercase().as_str() {
+                "SKIP" => Some(drop_namespace_request::Mode::Skip),
+                "FAIL" => Some(drop_namespace_request::Mode::Fail),
+                _ => None,
+            });
+            let behavior_enum = behavior.and_then(|b| match b.to_uppercase().as_str() {
+                "RESTRICT" => Some(drop_namespace_request::Behavior::Restrict),
+                "CASCADE" => Some(drop_namespace_request::Behavior::Cascade),
+                _ => None,
+            });
+            let request = DropNamespaceRequest {
+                id: if namespace.is_empty() {
+                    None
+                } else {
+                    Some(namespace)
+                },
+                mode: mode_enum,
+                behavior: behavior_enum,
+            };
+            let response = inner.drop_namespace(request).await.infer_error()?;
+            Python::with_gil(|py| -> PyResult<Py<PyDict>> {
+                let dict = PyDict::new(py);
+                dict.set_item("properties", response.properties)?;
+                dict.set_item("transaction_id", response.transaction_id)?;
+                Ok(dict.unbind())
+            })
         })
     }
 
     #[pyo3(signature = (namespace,))]
-    pub fn drop_namespace(
+    pub fn describe_namespace(
         self_: PyRef<'_, Self>,
         namespace: Vec<String>,
     ) -> PyResult<Bound<'_, PyAny>> {
         let inner = self_.get_inner()?.clone();
-        future_into_py(self_.py(), async move {
-            use lancedb::database::DropNamespaceRequest;
-            let request = DropNamespaceRequest { namespace };
-            inner.drop_namespace(request).await.infer_error()
+        let py = self_.py();
+        future_into_py(py, async move {
+            use lance_namespace::models::DescribeNamespaceRequest;
+            let request = DescribeNamespaceRequest {
+                id: if namespace.is_empty() {
+                    None
+                } else {
+                    Some(namespace)
+                },
+            };
+            let response = inner.describe_namespace(request).await.infer_error()?;
+            Python::with_gil(|py| -> PyResult<Py<PyDict>> {
+                let dict = PyDict::new(py);
+                dict.set_item("properties", response.properties)?;
+                Ok(dict.unbind())
+            })
+        })
+    }
+
+    #[pyo3(signature = (namespace=vec![], page_token=None, limit=None))]
+    pub fn list_tables(
+        self_: PyRef<'_, Self>,
+        namespace: Vec<String>,
+        page_token: Option<String>,
+        limit: Option<u32>,
+    ) -> PyResult<Bound<'_, PyAny>> {
+        let inner = self_.get_inner()?.clone();
+        let py = self_.py();
+        future_into_py(py, async move {
+            use lance_namespace::models::ListTablesRequest;
+            let request = ListTablesRequest {
+                id: if namespace.is_empty() {
+                    None
+                } else {
+                    Some(namespace)
+                },
+                page_token,
+                limit: limit.map(|l| l as i32),
+            };
+            let response = inner.list_tables(request).await.infer_error()?;
+            Python::with_gil(|py| -> PyResult<Py<PyDict>> {
+                let dict = PyDict::new(py);
+                dict.set_item("tables", response.tables)?;
+                dict.set_item("page_token", response.page_token)?;
+                Ok(dict.unbind())
+            })
         })
     }
 }